PMMatrix.h

//========================================================================================
// 
// $File$
// 
// Owner: Jeff Argast
// 
// $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.
// 
// 
// PMMatrix encapsulates the matrix math used in PM. It hides both the data type and
// the corresponding AGM matrix. It is possible to emulate the matrix math that occurs
// in AGM using the PMMatrix AGM methods.
// 
//========================================================================================

#ifndef __PMMatrix__
#define __PMMatrix__
 #include "K2Vector.h"
 #include "PMPoint.h"
 
//----------------------------------------------------------------------------------------
// Forward declarations
//----------------------------------------------------------------------------------------

class PMMatrix;
class PMRect;
class PMLineSeg;
class PMPolygon4;

 struct _t_BRVFixedMatrix;
 struct BRVCoordMatrix;

namespace dvacore {
 namespace geom {
 template <class T> class ScaleMatrixT;
 }
}


//----------------------------------------------------------------------------------------
// Typedefs
//----------------------------------------------------------------------------------------
 typedef K2Vector<PMMatrix> PMMatrixCollection;


 class PMMatrix
 {
 public:
 typedef base_type data_type;

 void ReadWrite(IPMStream *s);


//-------------------------------------------------------------------------------------
 constexpr PMMatrix() noexcept
 : fa(1.0), fb(0.0), fc(0.0), fd(1.0), fe(0.0), ff(0.0)
 {
 }

 constexpr PMMatrix( PMReal a, PMReal b, PMReal c, PMReal d, PMReal e, PMReal f) noexcept
 : fa(a), fb(b), fc(c), fd(d), fe(e), ff(f)
 {
 }

 constexpr PMMatrix(const PMMatrix &m) noexcept = default;
 constexpr PMMatrix(PMMatrix &&m) noexcept = default;

 PMMatrix(const BRVCoordMatrix &m);

 PMMatrix& operator=(const PMMatrix &m) noexcept = default;
 PMMatrix& operator=(PMMatrix &&m) noexcept = default;


 void SetMatrix (const BRVCoordMatrix &m);

 void SetMatrix (const _t_BRVFixedMatrix &m);

 void SetMatrix (const dvacore::geom::ScaleMatrixT<float> &m);
 
 void GetAGMFixedMatrix (_t_BRVFixedMatrix* retMatrix) const;

 void GetAGMFloatMatrix (BRVCoordMatrix* retMatrix) const;

 void GetUIMatrixF32 (dvacore::geom::ScaleMatrixT<float>* retMatrix) const;


 bool16 operator==(const PMMatrix& other) const;

 bool16 operator!=(const PMMatrix& other) const
 {
 return !(*this == other);
 }

 bool16 operator<(const PMMatrix& other) const;

//-------------------------------------------------------------------------------------

 void Transform(PMReal* x, PMReal* y) const;

 void Transform(PMPoint* p) const
 {
 Transform(&p->X(), &p->Y());
 }


 void Transform( PMPolygon4* fourPoints) const;


 void Transform(PMRect* rect) const;


 void Transform(PMLineSeg* segment) const;


//-------------------------------------------------------------------------------------
 

 const PMReal operator[](int index) const;


//-------------------------------------------------------------------------------------


 bool16 IsIdentity() const noexcept;
 bool exactly_identity() const noexcept; //Similar to IsIdentity, except exact comparison of double values is done and check is ordered based on
 //which elements are most likely to reveal non-identity. For all purposes, just use IsIdentity. Leaving this
 //function in place for historical reasons.

 void ResetToIdentity() noexcept;


 PMReal Determinant() const;


 bool16 IsSingular() const { return Determinant() == 0.0; }


 bool16 PreservesBoxes() const;


 void Invert();

 PMMatrix Inverse() const;



//-------------------------------------------------------------------------------------



 friend PMMatrix operator*( const PMMatrix &m1, const PMMatrix &m2);

 void PreConcat(const PMMatrix &m);

 void PostConcat(const PMMatrix &m);
 
 
 void PermuteLeftPast( const PMMatrix& m);

 void PermuteRightPast( const PMMatrix& m);
 


 
//-------------------------------------------------------------------------------------



 void PreScale( PMReal xScale, PMReal yScale);
 
 
 void Scale( PMReal xScale, PMReal yScale);


 const PMMatrix& ScaleFrom( const PMPoint& stationaryPoint, PMReal xScale, PMReal yScale)
 {
 Translate( -stationaryPoint.X(), -stationaryPoint.Y());
 Scale( xScale, yScale);
 Translate( stationaryPoint.X(), stationaryPoint.Y());
 return *this;
 }



 void SkewHorizontal( PMReal xSkewAngleInDegrees);

 void SkewVertical( PMReal ySkewAngleInDegrees);

 void SkewFrom( const PMPoint& stationaryPoint, PMReal skewAngle, PMReal noSkewDirectionAngle)
 {
 Translate( -stationaryPoint.X(), -stationaryPoint.Y());
 Rotate( -noSkewDirectionAngle);
 SkewHorizontal( skewAngle); //XFIssue LH coordinates
 Rotate( noSkewDirectionAngle);
 Translate( stationaryPoint.X(), stationaryPoint.Y());
 }



 void PreRotate( PMReal angleInDegrees);

 void Rotate( PMReal angleInDegrees);

 const PMMatrix& RotateAbout( const PMPoint& center, PMReal angle)
 {
 Translate( -center.X(), -center.Y());
 Rotate( angle); //XFIssue LH coordinates
 Translate( center.X(), center.Y());
 return *this;
 }


 void PreTranslate( PMReal x, PMReal y);
 inline void PreTranslate( const PMPoint& offset) { PreTranslate( offset.X(), offset.Y());}

 void Translate( PMReal x, PMReal y);
 inline void Translate( const PMPoint& offset) { Translate( offset.X(), offset.Y());}



//-------------------------------------------------------------------------------------


 void ScaleTo( PMReal xScale, PMReal yScale);
 void ScaleTo( const PMPoint& stationaryPoint, PMReal xScale, PMReal yScale);

 void SkewTo( PMReal xSkewAngleInDegrees);
 void SkewTo( const PMPoint& stationaryPoint, PMReal xSkewAngleInDegrees);
 void SkewToSlope( const PMPoint& stationaryPoint, PMReal skewSlope);

 void RotateTo( PMReal thetaInDegrees);
 void RotateTo( const PMPoint& stationaryPoint, PMReal thetaInDegrees);
 void RotateTo( const PMPoint& stationaryPoint, PMReal cosineAngle, PMReal sineAngle);

 void TranslateTo( PMReal x, PMReal y);
 void SetOrigin( PMReal x, PMReal y){ TranslateTo( x, y);}

 


//-------------------------------------------------------------------------------------

 

 /* An enumeration that specifies the factorization order used by GetMatrixFactors and GetTransformValues.
 For example, a value of kFactorOrder_SKRT specifies that the matrix should be factored into elementary
 transformation matrices in the order (scale)*(skew)*(rotate)*(translate). Note since matrix
 multiplication is not commutative, the factorization of a matrix depends on the desired factor order.
 Currently only kFactorOrder_SKRT and kFactorOrder_RKST are implemented. Passing any other TransformFactorOrder
 value will return an incorrect result.
 */
 enum TransformFactorOrder {
 kFactorOrder_SKRT = 0,
// kFactorOrder_SKTR,
// kFactorOrder_SRKT,
// kFactorOrder_SRTK,
// kFactorOrder_STKR,
// kFactorOrder_STRK,
//
// kFactorOrder_KSRT,
// kFactorOrder_KSTR,
// kFactorOrder_KRST,
// kFactorOrder_KRTS,
// kFactorOrder_KTSR,
// kFactorOrder_KTRS,
//
// kFactorOrder_RSKT,
// kFactorOrder_RSTK,
 kFactorOrder_RKST = 14,
// kFactorOrder_RKTS,
// kFactorOrder_RTSK,
// kFactorOrder_RTKS,
//
// kFactorOrder_TSKR,
// kFactorOrder_TSRK,
// kFactorOrder_TKSR,
// kFactorOrder_TKRS,
// kFactorOrder_TRSK,
// kFactorOrder_TRKS,
 kFactorOrder_End
 };


 static const uint32 kHasNoTransformContent = 0;
 static const uint32 kHasScaleContent = 1;
 static const uint32 kHasSkewContent = 2;
 static const uint32 kHasRotateContent = 4;
 static const uint32 kHasTranslateContent = 8;
 static const uint32 kHasAllTransformContent = (kHasScaleContent | kHasSkewContent | kHasRotateContent | kHasTranslateContent);

 uint32 GetMatrixFactors( 
 PMMatrix* scale, PMMatrix* skew, 
 PMMatrix* rotate, PMMatrix* translate,
 TransformFactorOrder factorOrder = kFactorOrder_SKRT
 ) const;


 uint32 GetTransformValues( 
 PMReal* xscale, PMReal* yscale, 
 PMReal* skewslope, 
 PMReal* costheta, PMReal* sintheta, 
 PMReal* xtranslation, PMReal* ytranslation,
 TransformFactorOrder factorOrder = kFactorOrder_SKRT
 ) const;


 uint32 GetMatrixContent() const;



 PMReal GetXScale() const;
 
 PMReal GetYScale() const;

 PMReal GetXSkewAngle() const;

 PMReal GetRotationAngle( bool16 zeroCentered = kFalse) const;

 PMReal GetXTranslation() const noexcept
 {
 return fe;
 }

 PMReal GetYTranslation() const noexcept
 {
 return ff;
 }



 // If you need rotation and any other the other values it is faster to call 
 // the following method instead of each of the above methods. Arguments may
 // be nil for those items you don't care about

 void GetMatrixInfo (PMReal* rotAngle, PMReal* xSkewAngle, PMReal* xScale, PMReal* yScale) const;
 

 void SanityCheck() const
 {
#if DEBUG
 SanityCheck_();
#endif
 }

 private:
 void SanityCheck_() const;
 void RotateTo(double cosine, double sine);
 uint32 GetTransformValues_SKRT(PMReal* xscale, PMReal* yscale, PMReal* skewslope, PMReal* costheta, PMReal* sintheta, PMReal* xtranslation, PMReal* ytranslation) const;
 uint32 GetTransformValues_RKST(PMReal* xscale, PMReal* yscale, PMReal* skewslope, PMReal* costheta, PMReal* sintheta, PMReal* xtranslation, PMReal* ytranslation) const;
 void InternalSkewTo(double k);


 PMReal fa, fb, fc, fd, fe, ff;
 };
 
 
#endif