Recent versions of Microsoft Windows support touch screens, which of course means that applications can respond to events originating from touches. Microsoft calls these events “gestures”.

Dyalog decided to add support for gestures to version 14.1 and so projects were planned, designs were designed, code was coded and, at Dyalog ’14 (#Dyalog14), a demonstration was demonstrated. The video of that demonstration is here

The three most interesting gestures are “pan”, “zoom” and “rotate”; I needed a good demo for the rotate gesture. I had an idea but was unsure how to implement it, so I decided to ask the team. Here’s the email I sent (any typos were included in the original email!):

*“Does any have code (or an algorithm, but code ‘d be better) to rotate a matrix by an arbitrary angle. The resulting matrix may then be larger than the original but will be filled with an appropriate value.
Does the question makes sense? For the conference I want to demonstrate 14.1 support for Windows touch gestures, one of which is a “rotate” gesture, and I thought that a good demo would be to rotate a CD cover image when the gesture is detected. So I need to be able to rotate the RGB values that make up the image.”*

There were a number of helpful responses, mainly about using rotation matrices, but what intrigued me was Jay Foad’s almost throw away comment: *“It’s also possible to do a rotation with repeated shears”*

That looked interesting, so I had a bit of a Google and found an article on *rotation by shearing* written by Tobin Fricke. The gist of this article is that shearing a matrix three times (first horizontally, then vertically and then again horizontally) effects a rotation. An interesting aspect of this (as compared to the rotation method) is that no information is lost. Every single pixel is moved and there is no loss of quality of the image.

I’m no mathematician, but I could read my way though enough of that to realise that it would be trivial in APL. The only “real” code needed is to figure how much to shear each line in the matrix.

Converting Fricke’s `α=-tan(Θ/2)`

and `ϐ=sin(Θ)`

, we get (using `⍺`

for `Θ`

):

```
a←-3○⍺÷2
b←1○⍺
```

and so, for a given matrix, the amounts to shift are given by:

`⌊⍺×(⍳≢⍵)-0.5×≢⍵`

where `⍺`

is either `a`

or `b`

, depending on which shift we are doing.

Wrapping this in an operator (where `⍺⍺`

is either `⌽`

or `⊖`

):

```
shear←{
(⌊⍺×(⍳≢⍵)-0.5×≢⍵)⍺⍺ ⍵
}
```

Our three shears of matrix `⍵`

, of size `s`

, can therefore be written as:

```
a⌽shear b⊖shear a⌽shear(3×s)↑(-2×s)↑⍵
```

Note the resize and pad of the matrix before we start so that we don’t replicate the edges of the bitmap. The padding elements are zeros and display as black pixels. They have been removed from the images below for clarity.

The final rotate function is:

```
rotate←{
shear←{(⌊⍺×(⍳≢⍵)-0.5×≢⍵)⍺⍺ ⍵}
a←-3○⍺÷2 ⋄ b←1○⍺ ⋄ s←⍴⍵
a⌽shear b⊖shear a⌽shear(3×s)↑(-2×s)↑⍵
}
```

Let’s look at a 45° rotate of a bitmap called “jd”.

`jd.CBits←(○.25)rotate jd.CBits`

Prior to performing any shears our image is:

After the first shear it becomes:

After the second shear it is:

And after the third shear it is:

All nicely rotated.