Sometimes, it would be nice to flatten (merge) multiple transforms into a single transform. Therefore, I thought it would be fun to figure out how to do this and share it with others.

Posts in this series:

- Zeroing the Center of a CompositeTransform
- Flattening a TransformGroup
- Using Matrices to Flatten a TransformGroup
- PanView - A Metro Panning Custom Control
- PanView - The Design

A transform consists of the following operations, performed in the following order:

- Translate
- Rotate about a center point
- Scale

**Note**: This task is difficult enough when flattening transforms with center points of 0,0. Having to account for transformations with center points not at the origin is just too much. Therefore, it is assumed that all transformations have their center points zeroed out as described in Zeroing the Center of a CompositeTransform.

In the above render, the red rectangle is transformed `Tx=100`

, `Ty=30`

, and `R=45`

. Remember that all center points are `0,0`

. The green rectangle is positioned using a group of two transforms, `Tx=100`

, `Ty=30`

, `R=45`

and then `Tx=120`

, `Ty=-80`

, and `R=-60`

. The goal of this post is to come up with an equivalent single transformation that results in the same location as the green rectangle. The answer is the transformation `Tx=241`

, `Ty=58`

and `R=-15`

, and rendered as the blue border.

### FlattenExample.xaml

```
<Page
x:Class="PanViewDemoApp.FlattenExample"
IsTabStop="false"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:local="using:PanViewDemoApp"
xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
mc:Ignorable="d"
FontSize="20"
Foreground="Black">
<Canvas>
<Border
Height="120"
Width="200"
Background="#40FF0000">
<Border.RenderTransform>
<CompositeTransform
x:Name="J"
TranslateX="100"
TranslateY="30"
Rotation="45" />
</Border.RenderTransform>
<TextBlock
Foreground="Red"
Margin="5">Tx=100 Ty=30 R=45</TextBlock>
</Border>
<Border
Height="120"
Width="200"
Background="#4000FF00">
<Border.RenderTransform>
<TransformGroup>
<CompositeTransform
x:Name="K"
TranslateX="120"
TranslateY="-80"
Rotation="-60" />
<CompositeTransform
TranslateX="100"
TranslateY="30"
Rotation="45" />
</TransformGroup>
</Border.RenderTransform>
<TextBlock
Foreground="Green"
Margin="3">Tx=100
Ty=30 R=45<LineBreak />Tx=120 Ty=-80 R=-60</TextBlock>
</Border>
<Border
Height="120"
Width="200"
BorderBrush="Blue"
BorderThickness="3">
<Border.RenderTransform>
<CompositeTransform
x:Name="L"
TranslateX="241"
TranslateY="58"
Rotation="-15" />
</Border.RenderTransform>
<TextBlock
Foreground="Blue"
Margin="3"
VerticalAlignment="Bottom">Tx=241 Ty=58 R=-15</TextBlock>
</Border>
</Canvas>
</Page>
```

Above is the XAML that created the rendering.

From my perspective, the order of transforms specified in the `TransformGroup`

are applied in reverse order. I have no idea whether this is a bug or by design. In any case, we have to work with what we have.

Now that we named the transformations, let me restate the goal of this post in different terms: Our goal is to modify the transform `J`

so that it is equivalent to the group of the transformations `J`

and `K`

.

```
<CompositeTransform
x:Name="J"
TranslateX="100"
TranslateY="30"
Rotation="45" />
<CompositeTransform
x:Name="K"
TranslateX="120"
TranslateY="-80"
Rotation="-60" />
```

The easy part is the rotation. Rotations are simply additive. Therefore:

`j.Rotation += k.Rotation;`

The harder part is applying the translation, since translations in the `x`

and `y`

direction of transform `K`

are now rotated 45° (because transform `J`

has already been applied). The easiest way to apply the translation is to first convert the translations of `K`

from rectangular `(x,y)`

to polar form. In this example, moving `120x,-80y`

is the same as moving `144.2`

pixels in a direction of `-33°`

. Therefore, we need to translate `144.2`

pixels in a direction of `(45-33)°`

or `12°`

.

By the way, it is important to note that a move in the positive `y`

direction is upwards in trigonometry and downward in Windows. A rotation in a positive direction is counter-clockwise in trigonometry and clockwise in Windows. Therefore. it is easy to make direction mistakes when using trigonometry functions in Windows. Yet, these two inconsistencies can actually cancel each other out very nicely. Just keep it in mind when reading the code below. Oh, and one more thing: rotations in Windows are specified in degrees and angles used in trigonometric functions are all specified in radians.

The first number, `144.2`

, is computed as:

`var d = Math.Sqrt(k.TranslateX * k.TranslateX + k.TranslateY * k.TranslateY);`

The second number, `-33°`

, is computed as:

`var a = Math.Atan2(k.TranslateY, k.TranslateX);`

We now need to add `45°`

to the angle, making sure to convert `45°`

to radians first.

`a += j.Rotation *`

`Math.PI / 180;`

Now that we have the final angle for `K`

, we need to break it back down into screen `x`

and `y`

distances for `K`

:

`var x = Math.Cos(a) * d;`

`var y = Math.Sin(a) * d;`

Finally, we can add those translations back into J:

`j.TranslateX += x;`

`j.TranslateY += y;`

Here is the C# code that performs the flattening of two transformations:

*TransformExtensions.cs*

```
static void InternalAppend(ICompositeTransform j, ICompositeTransform k)
{
InternalZeroCenterPoint(j);
InternalZeroCenterPoint(k);
var d = Math.Sqrt(k.TranslateX * k.TranslateX + k.TranslateY * k.TranslateY);
var a = Math.Atan2(k.TranslateY, k.TranslateX);
a += j.Rotation * Math.PI / 180;
var x = Math.Cos(a) * d;
var y = Math.Sin(a) * d;
j.Rotation += k.Rotation;
j.TranslateX += x;
j.TranslateY += y;
}
```