# [cairo] Rotations with Quaternions

Bill Spitzak spitzak at gmail.com
Mon Jan 22 20:06:06 UTC 2018

```Although only a 3x3 matrix is needed to specify an perspective transform,
if you want to use 3D rotations you need to use 4x4 matrix. This is because
the result of a rotation depends on the position of the camera from the
rotation origin and also the projection (ie fov) being used, and describing
that requires more than 9 numbers. I feel supporting 4x4 matrix is not a
good idea and thus supporting perspective using rotation is also not a good
idea.

It looks like a "perspective" operation that takes two numbers which I will
call px and py will work and kind of match cairo's current transformation
concatenation. What this does is premultiply the CTM by the matrix [[1 0 0]
[0 1 0] [px py 1]] (in an arrangement where cairo_matrix_t is described as
[[xx xy x0] [yx yy y0] [0 0 1]].

px is 1/x where x is the location of the vanishing point along the x axis.
py is 1/y where y is the location of the vanishing point along the y axis.

The attached images show a 512x512 image where there first is a translate
by 256,256, then a perspective operation, then a translate by -256,-256
(the effect of these transformations is to put the origin in the middle of
the image). In the first sample the perspective is 1/256,0. In the second
it is 0,1/256. In the third it is 1/256,1/256. If you look carefully you
can see the lines converge in each of them at the center of the edges, ie
256 units away from the origin.

​
If the translation is non-zero then the perspective will produce a w (the
lower-right corner of the matrix) that is not 1.0. I think this needs to be
preserved, rather than attempting to normalize the matrix. This is because
it could be zero, but further transforms can restore a non-zero value. The
normalization can be applied when the matrix is used to make projections.

If a client has figured out a projection matrix it wants, it is possible
but really difficult to decompose this into a perspective and
cairo_matrix_t. So you almost certainly want to add an equivalent of
cairo_transform and cairo_set_matrix that take a 3x3 matrix directly. To
make it easy to call with matrixes computed by modern 3d libraries, it
would be best to also take a 4x4 matrix in *column major order* and ignore
the 3rd row and column. In such a matrix a cairo_matrix_t and perspective
would be the following 16 numbers in this order: [xx yx ? px xy yy ? py ? ?
? ? x0 y0 ? 1], ? are ignored numbers.

Perspective also brings up questions about what to do about the line width,
dash patterns, and the font. IMHO applying perspective to these would break
all kinds of optimizations. The only useful thing to support is perspective
transforms of images. It may also be useful to transform path points by it.
For the same reason rotations don't work, it is useless for the client to
provide a 'z' value, you can only draw paths in the projected plane. To
logically support this you certainly need "line width locking" so changing
the CTM does not change the lines.

Another approach that may be more useful is to simply add three xy->uv
pairs to the source image, as an enhancement of the origin-setting code.
These specify that the location uv in the source will end up at xy in the
CTM. Actually the more I think about it, the better this sounds. This gets
the only useful part of 3D that anybody expects Cairo to support, and
allows a program doing it's own 3D projections to easily texture-map a
triangle that has uv coordinates.

On Fri, Jan 19, 2018 at 3:36 PM, Bryce Harrington <bryce at osg.samsung.com>
wrote:

> On Wed, Jan 10, 2018 at 02:13:39PM -0500, cecashon at aol.com wrote:
> >
> >
> > Hi Bryce,
> >
> > A 3x3 matrix should might work for quaternion rotations. In the sample
> > code this is reduced to a 2x2 matrix, or four variables for each
> > circle rotation, by using initial reference points but that wouldn't
> > work in general to preserve rotations. There would be a need to keep
> > the z component of a plane to make the rotations additive. If you
> > assumed z=0 then a first rotation would work but not a second or it
> > wouldn't work as expected.
> >
>
> The code I've been hacking on adds to Cairo a 3x3 matrix with the 9th
> element fixed to 1 (so effectively is an 8-element matrix).  If that
> last element is needed, it shouldn't be too hard to add in subsequently;
> I've hidden the matrix definition internally so it'd be no API break to
> change, just making sure all the math accounts for the transformation.
>
> > This probably is something difficult to add to Cairo. There are a lot
> > of places that the cairo_matrix_t touches in the code. Also I think
> > there would be a need for a new matrix for quaternion rotations and if
> > that is done then you run into further difficulties such as the order
> > of matrix multiplication. A lot of speculation at this point.
>
> Yes, it is proving to be rather difficult.  Actually, just expanding the
> cairo_matrix_t definition to include projection wasn't too bad, but
> keeping the cairo_matrix_t API intact and adding projection as a new
> matrix type is rather invasive - everywhere that uses cairo_matrix_t
> needs updated to handle a cairo_matrix3_t.
>
> But, I'm working my way through it, and I think once that's in place
> then I think the quaternion rotation is doable.  Since internally Cairo
> assumes a 2D surface (Z=0), perhaps some flattening operation would
> allow using 9-elements externally and avoid a lot of logical mess by
> using 8 internally.
>
> > I got going on this to figure out 3d rotations using Cairo's api. I
> > could get some special case rotations in 3d but not something that
> > would work for a gyro. Working on putting together a little gyro
> > widget with Cairo and GTK.
> >
> > I am not familiar with the internals of Cairo. I have looked around a
> > little but I don't have a test setup with the current version. Do you
> > have any suggestions for putting together a test setup? I would be
> > interested in getting a test build set up that I could experiment
> > with. Also to take a look at what you have going with projections.
>
> Depends on what operating system you're on.
>
> If you're on Linux it's just `apt-get build-dep libcairo2-dev` or the
> equivalent for your distro to install the build dependencies, checkout
> the code from git, and build it.  See INSTALL and README.
>
> There's more tips on the download page and elsewhere, although can't
> vouch for how current the directions are:
>
>     https://cairographics.org/end_to_end_build_for_win32/
>
> For experimenting with the matrix code, the good thing is that even just
> the image backend will be suitable, so don't have to worry about driver
> issues at least.  :-)
>
> Bryce
> --
> cairo mailing list
> cairo at cairographics.org
> https://lists.cairographics.org/mailman/listinfo/cairo
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <https://lists.cairographics.org/archives/cairo/attachments/20180122/f0d8280a/attachment-0001.html>
-------------- next part --------------
A non-text attachment was scrubbed...
Name: x2.png
Type: image/png
Size: 57673 bytes
Desc: not available
URL: <https://lists.cairographics.org/archives/cairo/attachments/20180122/f0d8280a/attachment-0003.png>
-------------- next part --------------
A non-text attachment was scrubbed...
Name: x1.png
Type: image/png
Size: 64487 bytes
Desc: not available
URL: <https://lists.cairographics.org/archives/cairo/attachments/20180122/f0d8280a/attachment-0004.png>
-------------- next part --------------
A non-text attachment was scrubbed...
Name: x3.png
Type: image/png
Size: 71284 bytes
Desc: not available
URL: <https://lists.cairographics.org/archives/cairo/attachments/20180122/f0d8280a/attachment-0005.png>
```