"{ Package: 'stx:libview2' }"

DisplayTransform variableFloatSubclass:#MatrixTransform2x3

	instanceVariableNames:''

	classVariableNames:''

	poolDictionaries:''

	category:'Graphics-Transformations'

!

MatrixTransform2x3 comment:'This class represents a transformation for points, that is a combination of scale, offset, and rotation. It is implemented as a 2x3 matrix containing the transformation from the local coordinate system in the global coordinate system. Thus, transforming points from local to global coordinates is fast and cheap whereas transformations from global to local coordinate systems are relatively expensive.

!MatrixTransform2x3 class methodsFor:'instance creation'!

identity

new

transformFromLocal: localBounds toGlobal: globalBounds

	^((self withOffset: (globalBounds center)) composedWithLocal:

		(self withScale: (globalBounds extent / localBounds extent) asFloatPoint))

			composedWithLocal: (self withOffset: localBounds center negated)

"

	^(self identity)

		setScale: (globalBounds extent / localBounds extent) asFloatPoint;

		setOffset: localBounds center negated asFloatPoint;

		composedWithGlobal:(self withOffset: globalBounds center asFloatPoint)

withAngle: angle

withOffset: aPoint

withRotation: angle

withScale: aPoint

!MatrixTransform2x3 methodsFor:'accessing'!

at: index

"/        <primitive: 'primitiveFloatArrayAt'>

"/        ^Float fromIEEE32Bit: (self basicAt: index)

          ^ self basicAt: index

!

at: index put: value

"/        <primitive: 'primitiveFloatArrayAtPut'>

"/        value isFloat 

"/                ifTrue:[self basicAt: index put: value asIEEE32BitWord]

"/                ifFalse:[self at: index put: value asFloat].

"/        ^value

        ^ self basicAt: index put:value

!

inverseTransformation

	"Return the inverse transformation of the receiver.

	The inverse transformation is computed by first calculating

	the inverse offset and then computing transformations

	for the two identity vectors (1@0) and (0@1)"

	| r1 r2 r3 m |

	r3 _ self invertPoint: 0@0.

	r1 _ (self invertPoint: 1@0) - r3.

	r2 _ (self invertPoint: 0@1) - r3.

	m _ self species new.

	m

		a11: r1 x; a12: r2 x; a13: r3 x;

		a21: r1 y; a22: r2 y; a23: r3 y.

offset

offset: aPoint

	self a13: aPoint x asFloat.

!MatrixTransform2x3 methodsFor:'comparing'!

= MatrixTransform2x3

        | length |

"/        <primitive:'primitiveFloatArrayEqual'>

        self class = MatrixTransform2x3 class ifFalse:[^false].

        length _ self size.

        (length = MatrixTransform2x3 size) ifFalse:[^false].

        1 to: self size do:[:i| (self at: i) = (MatrixTransform2x3 at: i) ifFalse:[^false]].

        ^true

!

hash

        | result |

"/        <primitive:'primitiveFloatArrayHash'>

"/        result _ 0.

"/        1 to: self size do:[:i| result _ result + (self basicAt: i) ].

"/        ^result bitAnd: 16r1FFFFFFF

        result _ 0.

        1 to: self size do:[:i| result _ result + (self basicAt: i) hash ].

        ^result bitAnd: 16r1FFFFFFF

! !

!MatrixTransform2x3 methodsFor:'composing'!

composedWithLocal: aTransformation

	"Return the composition of the receiver and the local transformation passed in"

	aTransformation isMatrixTransform2x3 ifFalse:[^super composedWith: aTransformation].

composedWithLocal: aTransformation into: result

        "Return the composition of the receiver and the local transformation passed in.

        Store the composed matrix into result."

        | a11 a12 a13 a21 a22 a23 b11 b12 b13 b21 b22 b23 matrix |

"/        <primitive: 'm23PrimitiveComposeMatrix'>

        matrix _ aTransformation asMatrixTransform2x3.

        a11 _ self a11.                 b11 _ matrix a11.

        a12 _ self a12.                 b12 _ matrix a12.

        a13 _ self a13.                 b13 _ matrix a13.

        a21 _ self a21.                 b21 _ matrix a21.

        a22 _ self a22.                 b22 _ matrix a22.

        a23 _ self a23.                 b23 _ matrix a23.

        result a11: (a11 * b11) + (a12 * b21).

        result a12: (a11 * b12) + (a12 * b22).

        result a13: a13 + (a11 * b13) + (a12 * b23).

        result a21: (a21 * b11) + (a22 * b21).

        result a22: (a21 * b12) + (a22 * b22).

        result a23: a23 + (a21 * b13) + (a22 * b23).

        ^result

! !

!MatrixTransform2x3 methodsFor:'converting'!

asMatrixTransform2x3

!MatrixTransform2x3 methodsFor:'element access'!

a11

a11: value

a12

a12: value

a13

a13: value

a21

a21: value

a22

a22: value

a23

a23: value

!MatrixTransform2x3 methodsFor:'initialize'!

setIdentiy

	"Initialize the receiver to the identity transformation (e.g., not affecting points)"

	self

		a11: 1.0; a12: 0.0; a13: 0.0;

!MatrixTransform2x3 methodsFor:'printing'!

printOn: aStream

	aStream 

		nextPutAll: self class name;

		nextPut: $(;

		cr; print: self a11; tab; print: self a12; tab; print: self a13;

		cr; print: self a21; tab; print: self a22; tab; print: self a23;

!MatrixTransform2x3 methodsFor:'private'!

setAngle: angle

	"Set the raw rotation angle in the receiver"

	| rad s c |

	rad := angle degreesToRadians.

	s := rad sin.

	c := rad cos.

	self a11: c.

	self a12: s negated.

	self a21: s.

setOffset: aPoint

setScale: aPoint

!MatrixTransform2x3 methodsFor:'testing'!

isIdentity

        "Return true if the receiver is the identity transform; that is, if applying to a point returns the point itself."

"/        <primitive: 'm23PrimitiveIsIdentity'>

        ^self isPureTranslation and:[self a13 = 0.0 and:[self a23 = 0.0]]

!

isMatrixTransform2x3

	"Return true if the receiver is 2x3 matrix transformation"

isPureTranslation

        "Return true if the receiver specifies no rotation or scaling."

"/        <primitive: 'm23PrimitiveIsPureTranslation'>

        ^self a11 = 1.0 and:[self a12 = 0.0 and:[self a22 = 0.0 and:[self a21 = 1.0]]]

! !

!MatrixTransform2x3 methodsFor:'transforming points'!

globalPointToLocal: aPoint

        "Transform aPoint from global coordinates into local coordinates"

"/        <primitive: 'm23PrimitiveInvertPoint'>

        ^(self invertPoint: aPoint) rounded

!

invertPoint: aPoint

	"Transform aPoint from global coordinates into local coordinates"

	| x y det a11 a12 a21 a22 detX detY |

	x _ aPoint x asFloat - (self a13).

	y _ aPoint y asFloat - (self a23).

	a11 _ self a11.	a12 _ self a12.

	a21 _ self a21.	a22 _ self a22.

	det _ (a11 * a22) - (a12 * a21).

	det = 0.0 ifTrue:[^0@0]. "So we have at least a valid result"

	det _ 1.0 / det.

	detX _ (x * a22) - (a12 * y).

	detY _ (a11 * y) - (x * a21).

localPointToGlobal: aPoint

        "Transform aPoint from local coordinates into global coordinates"

"/        <primitive: 'm23PrimitiveTransformPoint'>

        ^(self transformPoint: aPoint) rounded

!

transformPoint: aPoint

!MatrixTransform2x3 methodsFor:'transforming rects'!

globalBounds: srcRect toLocal: dstRect

        "Transform aRectangle from global coordinates into local coordinates"

"/        <primitive:'m23PrimitiveInvertRectInto'>

        ^super globalBoundsToLocal: srcRect

!

globalBoundsToLocal: aRectangle

	"Transform aRectangle from global coordinates into local coordinates"

localBounds: srcRect toGlobal: dstRect

        "Transform aRectangle from local coordinates into global coordinates"

"/        <primitive:'m23PrimitiveTransformRectInto'>

        ^super localBoundsToGlobal: srcRect

!

localBoundsToGlobal: aRectangle

	"Transform aRectangle from local coordinates into global coordinates"

!MatrixTransform2x3 class methodsFor:'documentation'!

version

! !