Merge lp:~andreas-pokorny/mir/add-geometry-transformation into lp:mir

[Andreas Pokorny]

Adds a class describing a co-ordinate transformation

geometry::Transformation describes a combination of scaling, translation and rotation. Rotation is limited to rotation around the centre of the given object. In an upcoming change this class should be used to describe the position of a surface in a scene, and thus also used to do co-ordinate transformations for hit testing and input dispatching.
The transformation is stored in a way that trivial cases can be detected, and that transformation parameters can be read and changed.

This adds a class to geometry that should encapsulate transformations of surfaces in a way that:

* the structure of the transformation is visible - to allow changes of parts of the transformation
* the inverse of the transformation is available and or can be calculated in a cheap way without precision issues - to get relative co-ordinates for touch dispatching
* caches matrices and supports transformation short cuts to avoid more expensive calculations for display or input dispatch

This class is used to remove more of android input stacks InputWindowInfo and to move that into input::Surface instead.

It might need a better name.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:1473
No commit message was specified in the merge proposal. Click on the following link and set the commit message (if you want a jenkins rebuild you need to trigger it yourself):
https://code.launchpad.net/~andreas-pokorny/mir/add-geometry-transformation/+merge/211733/+edit-commit-message

http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-ci/1111/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-trusty-i386-build/1298
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-trusty-amd64-build/1296
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-trusty-touch/878
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-trusty-amd64-ci/843
        deb: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-trusty-amd64-ci/843/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-trusty-armhf-ci/848
        deb: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-trusty-armhf-ci/848/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-trusty-armhf/879
        deb: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-trusty-armhf/879/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-runner-mako/821
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/4992

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mir-team-mir-development-branch-ci/1111/rebuild

review: Needs Fixing (continuous-integration)

[Daniel van Vugt (vanvugt)]

All points I mentioned yesterday...

(1) "Transformation" is probably too generic a term for something with very specific operations like this. It needs a name that better distinguishes it from a common "mat4 transformation".

(2) Rotation is somewhat limited. We presently support rotations around arbitrary axes whereas this proposal limits that to only 3 possible axes. Although given the render_surfaces demo is probably going to be the only user of this, that's OK, but...

(3) As render_surfaces is the only user of rotations, rotations should not be explicitly built into the class. They should be provided by render_surfaces as simply a matrix.

(4) Only supporting one order of operations is too restrictive:
161 + * The transformation is defined as:
162 + * translate(translation) * translate(size*scale/2) * rotation(y,x,z) * scale * translate(-size*scale/2)
Transformations are arbitrary and should always be arbitrary. Imposing only one order and fixed set of operations would be an unacceptable step backwards.

Overall, I think the Transformation class is a mistake. Too restrictive in that it makes transformations less flexible, and more complicated at the same time. We should only deal in mat4's and never try to disassemble a mat4 into separate transformations.

review: Disapprove

[Daniel van Vugt (vanvugt)]

I think the right answer is to expose a simple interface to convert screen coordinates (touch/pointer coords) into surface space by adding a function:

  geometry::Point Surface::screen_to_local(geometry:Point const& p) const
  {
      // calculate some answer using transformation(), top_left() and size() info.
      // You may even wish to ignore per-surface transformations and only return valid results
      // when transformation() == identity. In which case it could be as trivial as:
      // return p - top_left();
      // or more complicated like:
      // auto centre = top_left() + (size() / 2);
      // return inverse(transformation()) * (p - centre);
  }

That's a function instead of a class. It doesn't even need to be a method of Surface because it just uses existing public interface functions.

[Andreas Pokorny (andreas-pokorny)]

> All points I mentioned yesterday...
>
> (1) "Transformation" is probably too generic a term for something with very
> specific operations like this. It needs a name that better distinguishes it
> from a common "mat4 transformation".

I was looking for a new name.

> (2) Rotation is somewhat limited. We presently support rotations around
> arbitrary axes whereas this proposal limits that to only 3 possible axes.
> Although given the render_surfaces demo is probably going to be the only user
> of this, that's OK, but...

(2 and 4) Current status is a super set of what was in use so far.
Translation & scaling in the android input stack, and rotations and translation in our examples/surface code.
I want to enhance the interface in later steps. I think the necessary features in that domain are neither arbitrary nor infinite.

> (3) As render_surfaces is the only user of rotations, rotations should not be
> explicitly built into the class. They should be provided by render_surfaces as
> simply a matrix.

I disagree to such an interface, because
* makes the interface more complicated to use
* requires the caller to track additional state since manipulating a matrix incrementally is not practical.
* trivial positioning and orientation cases are not easy to detect.

> (4) Only supporting one order of operations is too restrictive:
> 161 + * The transformation is defined as:
> 162 + * translate(translation) * translate(size*scale/2) *
> rotation(y,x,z) * scale * translate(-size*scale/2)
> Transformations are arbitrary and should always be arbitrary. Imposing only
> one order and fixed set of operations would be an unacceptable step backwards.

see (2) and

>
> Overall, I think the Transformation class is a mistake. Too restrictive in
> that it makes transformations less flexible, and more complicated at the same
> time. We should only deal in mat4's and never try to disassemble a mat4 into
> separate transformations.

[Daniel van Vugt (vanvugt)]

transformations that will be used in animations are arbitrary, and must remain so. You can't divide an arbitrary transformation matrix into a set of meaningful simple ones. Consider what happens in a cube-style animation where the windows fly away into the screen and layer onto a cube. The cube rotates around a point in space that is "inside the screen" and around an arbitrary axis determined by the mouse drag direction. That is a non-trivial surface transformation which involves translations and rotations in more combinations than this proposal supports. A 4x4 matrix is enough to represent such a transformation. However you cannot unwind that matrix into the simple set of steps used to create the matrix.

I recall sabdfl has used the cube example multiple times when asking about capabilities. Compiz/Ubuntu can do it right now and of course we need to build something better than Compiz.

And of course, multiple animations run at once. Not just one. So surface->transformation() could represent any number of animations being applied simultaneously.

Regarding "complicated", what I am suggesting is a simple function of only a few lines. That is less complicated than this proposal. Although my previous example contained a mistake. It should read:

  geometry::Point Surface::screen_to_local(geometry:Point const& p) const
  {
      auto centre = top_left() + (size() / 2);
      return (inverse(transformation()) * (p - centre)) + centre;
  }

Admittedly, that does require a full inverse.

[Andreas Pokorny (andreas-pokorny)]

> transformations that will be used in animations are arbitrary, and must remain
> so. You can't divide an arbitrary transformation matrix into a set of
> meaningful simple ones. Consider what happens in a cube-style animation where
> the windows fly away into the screen and layer onto a cube. The cube rotates
> around a point in space that is "inside the screen" and around an arbitrary
> axis determined by the mouse drag direction. That is a non-trivial surface
> transformation which involves translations and rotations in more combinations
> than this proposal supports. A 4x4 matrix is enough to represent such a
> transformation. However you cannot unwind that matrix into the simple set of
> steps used to create the matrix.

The issue is rather the lack of a z co-ordinate that would require ordering of the surfaces before they hit the screen. And the lack of perspective transformation inside the renderer. And then of course the then lacking but necessary ray casting to find the surface for input hit testing - or usage of points vs polygon to do hit testing.

Regarding rotations this case is already possible but requires calculating the final orientation of the surface as three angles and its position. Also not optimal to do.

Again I dont think that interface of the Thing meant to be an encapsulation of the transformations defining orientation and position and scaling of surface is done or complete - it is roughly what we have in use right now. So yes both implementation and interface will change a lot if we get the time to improve. But I think that is something we might evolve when turning mir::scene into a more complete scene graph?

> I recall sabdfl has used the cube example multiple times when asking about
> capabilities. Compiz/Ubuntu can do it right now and of course we need to build
> something better than Compiz.
>
> And of course, multiple animations run at once. Not just one. So
> surface->transformation() could represent any number of animations being
> applied simultaneously.
>
> Regarding "complicated", what I am suggesting is a simple function of only a
> few lines. That is less complicated than this proposal. Although my previous
> example contained a mistake. It should read:
>
> geometry::Point Surface::screen_to_local(geometry:Point const& p) const
> {
> auto centre = top_left() + (size() / 2);
> return (inverse(transformation()) * (p - centre)) + centre;
> }
>
> Admittedly, that does require a full inverse.

Additionally that does not simplify the example above either. And as you noticed you would inverse on each transformation, which is something I thought we both agreed to be bad.

I believe we can find a better way to describe arbitrary placed surfaces than to do:
  void set_transformation( mat4 worldToLocal, mat4 localToWorld);

[kevin gunn (kgunn72)]

@tranformation being just completely the wrong approach
personally I can see that a generic and yet simple (meaning non-arbitrary) convenience interface might still be useful, as in the definition of convenient. I guess the test question to ask is...is that something people would find useful to use in general, e.g. is it common enough??
i see the argument for rotation it'd only used by render_surfaces demo today, but would there be other customers potentially?

@ providing a simple function
looks like more arguing ahead :) might just be worth it to deliver a simple function to progress. Please consider.

@inverse - why is it bad ?

@ finding a better way for arbitrary surface positioning and mat4
my thinking would be, some conveniences are worthhwile, but at the same time, surely there's a breakover point where you would just use set_transformation( mat4 worldToLocal, mat4 localToWorld);
It goes back to the test question...if we build a better interface, who will use it?

[Daniel van Vugt (vanvugt)]

"lack of a z coordinate" is both untrue, and not an issue. It's important to remember that stacking depth does not and will not affect the Z coordinate used to render a surface. The stacking depth only affects the surface's position in the render list. Surfaces are all given zero Z coordinates by default, but that can and will change as the result of transformations.

We do support Z coordinates, although they're all set to zero right now. And we can easily support perspective projection in the renderer. Just no one has implemented it yet.

That does raise the issue of you technically having to include the display_transformation to get accurate input coordinates, which we're not doing. I've repeated this point every time we've discussed the topic. You can either choose to ignore full-screen transformations for input handling, or somehow work to extract that info from the renderer. Either is feasible but I'd prefer the former.

Always remember: a 4x4 matrix represents ANY number of transformations in ANY order. That's a fact that all graphics programmers depend on. And we should not in any way limit the number or order of transformations that a single matrix can represent.

[Daniel van Vugt (vanvugt)]

Basic 3D perspective implemented:
https://code.launchpad.net/~vanvugt/mir/perspective/+merge/212085

[Andreas Pokorny (andreas-pokorny)]

Strange world. This all started when I noticed that the transformation in BasicSurface was not used properly in the class and in input stack - ignored in some cases. When I suggested to fix that there were performance concerns, and concerns that we never need transformations at all. So I thought a way to "support" both by making it easy to detect possible short cut, not because it has a performance impact, but to avoid the concerns.

If we can settle on making mir calculate co-ordinates correctly in every case I am happy to not have that MP go into devel.

Unmerged revisions

1473. By Andreas Pokorny on 2014-03-18

Adds a class describing a co-ordinate transformation

geometry::Transformation describes a combination of scaling, translation and rotation. Rotation is limited to rotation around the center of the given object. In an upcoming change this class should be used to describe the position of a surface in a scene, and thus also used to do co-ordinate transformations for hit testing and input dispatching.
The transformation is storesd in a way that trivial cases can be detected, and that tranformation parameters can be read and changed.

=== modified file 'include/shared/mir/geometry/point.h'
--- include/shared/mir/geometry/point.h	2014-03-06 06:05:17 +0000
+++ include/shared/mir/geometry/point.h	2014-03-19 14:02:20 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright © 2012 Canonical Ltd.
+ * Copyright © 2012,2014 Canonical Ltd.
  *
  * This program is free software: you can redistribute it and/or modify it
  * under the terms of the GNU Lesser General Public License version 3,
@@ -21,6 +21,7 @@
 
 #include "dimensions.h"
 #include <iosfwd>
+#include <cmath>
 
 namespace mir
 {
@@ -50,6 +51,25 @@
     return lhs.x != rhs.x || lhs.y != rhs.y;
 }
 
+inline Point operator *(float lhs, Point const& rhs)
+{
+    return Point{std::round(rhs.x.as_float()*lhs),
+        std::round(rhs.y.as_float()*lhs)};
+}
+
+inline Point operator *(Point const& lhs, float rhs)
+{
+    return rhs*lhs;
+}
+
+inline Point operator /(Point const& lhs, float rhs)
+{
+    return Point{std::round(lhs.x.as_float()/rhs),
+        std::round(lhs.y.as_float()/rhs)};
+}
+
+
+
 std::ostream& operator<<(std::ostream& out, Point const& value);
 }
 }

=== added file 'include/shared/mir/geometry/transformation.h'
--- include/shared/mir/geometry/transformation.h	1970-01-01 00:00:00 +0000
+++ include/shared/mir/geometry/transformation.h	2014-03-19 14:02:20 +0000
@@ -0,0 +1,149 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Andreas Pokorny <[e-mail]>
+ */
+
+#ifndef MIR_GEOMETRY_TRANSFORMATION_H_
+#define MIR_GEOMETRY_TRANSFORMATION_H_
+
+#include "mir/geometry/displacement.h"
+#include "mir/geometry/size.h"
+#include "mir/geometry/rectangle.h"
+
+#include "glm/glm.hpp"
+
+namespace mir
+{
+
+namespace geometry
+{
+
+/*!
+ * \brief Transformation describes transformations applied to a rectangle.
+ */
+class Transformation
+{
+public:
+    Transformation();
+    explicit Transformation(Size rectangle_size);
+    explicit Transformation(Rectangle rectangle);
+
+    void update_size(Size rectangle_size);
+    /*!
+     * \brief Returns true when the transformation does not affect the co-ordinates of an object.
+     */
+    bool is_identity() const;
+    /*!
+     * \brief Returns true when the transformation only moves the object.
+     */
+    bool is_translation() const;
+    /*!
+     * \brief Returns true when the transformation only scales the object.
+     */
+    bool is_scaling() const;
+    /*!
+     * \brief Returns true when the transformation only moves the object and scales it with a single factor.
+     */
+    bool is_scaling_translation() const;
+    /*!
+     * \brief Returns true when the transformation contains at least a rotation,
+     * and might also contain movements and scaling operations.
+     */
+    bool requires_matrix_transformation() const;
+
+    /*!
+     * \brief Changes the scaling factor by the given \a scale.
+     */
+    void set_scale(float scale);
+    void set_translation(Displacement const& movement);
+    /*!
+     * \brief Rotation of the surface described as yxz angles
+     * \param y angle around the rotated y axis (yaw)
+     * \param x angle around the rotated x axis (pitch)
+     * \param z angle around the original z axis (roll)
+     */
+    void set_rotation(float y, float x, float z);
+    /*!
+     * \brief Rotation of the surface described as rotation around the z axis
+     */
+    void set_rotation(float z);
+
+    float get_z_rotation() const
+    {
+        return z_angle;
+    }
+
+    float get_x_rotation() const
+    {
+        return x_angle;
+    }
+
+    float get_y_rotation() const
+    {
+        return y_angle;
+    }
+
+    Displacement get_translation() const
+    {
+        return translation;
+    }
+
+    float get_scale() const
+    {
+        return scale;
+    }
+
+    /*!
+     * \brief Retuns the complete transformation matrix
+     *
+     * The transformation is defined as:
+     *   translate(translation) * translate(size*scale/2) * rotation(y,x,z) * scale * translate(-size*scale/2)
+     */
+    glm::mat4 get_matrix() const;
+    /*!
+     * \brief Retuns the inverted transformation matrix
+     */
+    glm::mat4 get_inverse_matrix() const;
+    /*!
+     * \brief Returns a transformation matrix lacking the translation.
+     */
+    glm::mat4 get_center_matrix() const;
+
+    Point transform_to_local(Point const& point) const;
+    Point transform_to_screen(Point const& point) const;
+private:
+    float scale;
+    Displacement translation;
+    Size size;
+
+    float x_angle, y_angle, z_angle;
+    mutable glm::mat4 matrix;
+    // center_matrix is just Rotate*Scale
+    mutable glm::mat4 center_matrix;
+    mutable glm::mat4 inverse_matrix;
+    mutable bool dirty;
+
+    void update_matrices() const;
+    bool has_scale() const;
+    bool has_translation() const;
+    bool has_rotation() const;
+};
+}
+
+}
+
+#endif
+

=== modified file 'src/shared/geometry/CMakeLists.txt'
--- src/shared/geometry/CMakeLists.txt	2014-03-06 06:05:17 +0000
+++ src/shared/geometry/CMakeLists.txt	2014-03-19 14:02:20 +0000
@@ -17,8 +17,9 @@
 add_library(
   mirsharedgeometry STATIC
 
+  ostream.cpp
   rectangle.cpp
   rectangles.cpp
-  ostream.cpp
+  transformation.cpp
 )
 

=== added file 'src/shared/geometry/transformation.cpp'
--- src/shared/geometry/transformation.cpp	1970-01-01 00:00:00 +0000
+++ src/shared/geometry/transformation.cpp	2014-03-19 14:02:20 +0000
@@ -0,0 +1,243 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Andreas Pokorny <[e-mail]>
+ */
+
+#include "mir/geometry/transformation.h"
+
+#define GLM_FORCE_RADIANS
+#include "glm/gtx/euler_angles.hpp"
+#include "glm/gtx/transform.hpp"
+
+#include <cmath>
+
+namespace geom = mir::geometry;
+
+//TODO
+// * Consider supporting separate scale values for x and y co-ordinates.
+// * Consider different forms of orientation / rotation descriptions.
+// * clamp scales close to 1.0f and angles close to 0.0f when they cannot be noticed
+//   on screen: i.e. sin(angle)*height/2 <1.0f or cos(angle)*width/2 < 1.0f
+
+geom::Transformation::Transformation(Rectangle rectangle)
+    : scale(1.0f),
+    translation(rectangle.top_left - geom::Point()),
+    size(rectangle.size),
+    x_angle(0.0f),
+    y_angle(0.0f),
+    z_angle(0.0f),
+    dirty(has_translation())
+{
+}
+geom::Transformation::Transformation(Size rectangle_size)
+    : Transformation(Rectangle{Point{0,0}, rectangle_size})
+{
+}
+
+geom::Transformation::Transformation()
+    : Transformation(Size(0,0) )
+{}
+
+bool geom::Transformation::has_scale() const
+{
+    return scale != 1.0f;
+}
+
+bool geom::Transformation::has_translation() const
+{
+    return translation != Displacement{};
+}
+
+bool geom::Transformation::has_rotation() const
+{
+    return !(x_angle == 0.0f && y_angle == 0.0f && z_angle == 0.0f);
+}
+
+bool geom::Transformation::is_identity() const
+{
+    return !has_translation() && !has_scale() && !has_rotation();
+}
+
+bool geom::Transformation::is_scaling() const
+{
+    return !has_translation() && has_scale() && !has_rotation();
+}
+
+bool geom::Transformation::is_translation() const
+{
+    return has_translation() && !has_scale() && !has_rotation();
+}
+
+bool geom::Transformation::is_scaling_translation() const
+{
+    return has_translation() && has_scale() && !has_rotation();
+}
+
+bool geom::Transformation::requires_matrix_transformation() const
+{
+    return has_rotation();
+}
+
+void geom::Transformation::update_size(Size size)
+{
+    if (this->size != size)
+    {
+        this->size = size;
+        dirty = true;
+    }
+}
+
+void geom::Transformation::set_scale(float scale)
+{
+    if (this->scale != scale)
+    {
+        dirty = true;
+        this->scale = scale;
+    }
+}
+
+void geom::Transformation::set_translation(Displacement const& movement)
+{
+    if (translation != movement)
+    {
+        dirty = true;
+        translation = movement;
+    }
+}
+
+glm::mat4 geom::Transformation::get_matrix() const
+{
+    update_matrices();
+    return matrix;
+}
+
+glm::mat4 geom::Transformation::get_center_matrix() const
+{
+    update_matrices();
+    return center_matrix;
+}
+
+void geom::Transformation::set_rotation(float y, float x, float z)
+{
+    if (y != y_angle ||
+        x != x_angle ||
+        z != z_angle)
+    {
+        dirty = true;
+        y_angle = y;
+        x_angle = x;
+        z_angle = z;
+    }
+}
+
+void geom::Transformation::set_rotation(float z)
+{
+    if (0.0f != y_angle ||
+        0.0f != x_angle ||
+        z != z_angle)
+    {
+        dirty = true;
+        y_angle = 0.0f;
+        x_angle = 0.0f;
+        z_angle = z;
+    }
+}
+
+void geom::Transformation::update_matrices() const
+{
+    if (!dirty)
+        return;
+
+    dirty = false;
+
+    if (has_rotation())
+    {
+        glm::vec3 center{size.width.as_float()/2.0f, size.height.as_float()/2.0f, 0.0};
+
+        if (x_angle == 0.0f && y_angle == 0.0f)
+        {
+            center_matrix = glm::eulerAngleZ(glm::radians(z_angle));
+        }
+        else
+        {
+            center_matrix = glm::eulerAngleYXZ(
+                glm::radians(y_angle),
+                glm::radians(x_angle),
+                glm::radians(z_angle));
+        }
+
+        matrix = glm::translate(center) * center_matrix * glm::translate(-center);
+        inverse_matrix = glm::translate(center) * glm::transpose(center_matrix) * glm::translate(-center);
+    }
+    else
+    {
+        center_matrix = glm::mat4{};
+        matrix = glm::mat4{};
+        inverse_matrix = glm::mat4{};
+    }
+    if (has_scale())
+    {
+        matrix = glm::scale(glm::vec3(scale)) * matrix;
+        center_matrix = glm::scale(glm::vec3(scale)) * center_matrix;
+        inverse_matrix *=  glm::scale(glm::vec3(1.0f/scale));
+    }
+
+    if (has_translation())
+    {
+        inverse_matrix *= glm::translate(glm::vec3{-translation.dx.as_float(), -translation.dy.as_float(), 0.0});
+
+        matrix = glm::translate(glm::vec3{translation.dx.as_float(), translation.dy.as_float(), 0.0}) * matrix;
+    }
+}
+
+glm::mat4 geom::Transformation::get_inverse_matrix() const
+{
+    update_matrices();
+
+    return inverse_matrix;
+}
+
+geom::Point geom::Transformation::transform_to_local(geom::Point const& point) const
+{
+    if (is_identity())
+        return point;
+    if (is_translation())
+        return point - translation;
+    if (is_scaling())
+        return point / scale;
+    if (is_scaling_translation())
+        return (point - translation)/ scale;
+
+    glm::mat4 inv( get_inverse_matrix() );
+    glm::vec4 pos = inv * glm::vec4{point.x.as_float(), point.y.as_float(), 0.0f, 1.0f};
+    return geom::Point{ std::round(pos.x), std::round(pos.y) };
+}
+
+geom::Point geom::Transformation::transform_to_screen(geom::Point const& point) const
+{
+    if (is_identity())
+        return point;
+    if (is_translation())
+        return point + translation;
+    if (is_scaling())
+        return point * scale;
+    if (is_scaling_translation())
+        return point * scale + translation;
+
+    glm::mat4 trans( get_matrix() );
+    glm::vec4 pos = trans * glm::vec4{point.x.as_float(), point.y.as_float(), 0.0f, 1.0f};
+    return geom::Point{ std::round(pos.x), std::round(pos.y) };
+}

=== modified file 'tests/unit-tests/geometry/CMakeLists.txt'
--- tests/unit-tests/geometry/CMakeLists.txt	2013-08-28 03:41:48 +0000
+++ tests/unit-tests/geometry/CMakeLists.txt	2014-03-19 14:02:20 +0000
@@ -5,6 +5,7 @@
   ${CMAKE_CURRENT_SOURCE_DIR}/test-displacement.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test-rectangle.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test-rectangles.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/test-transformation.cpp
 )
 
 set(UNIT_TEST_SOURCES ${UNIT_TEST_SOURCES} PARENT_SCOPE)

=== modified file 'tests/unit-tests/geometry/test-point.cpp'
--- tests/unit-tests/geometry/test-point.cpp	2013-08-28 03:41:48 +0000
+++ tests/unit-tests/geometry/test-point.cpp	2014-03-19 14:02:20 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright © 2012 Canonical Ltd.
+ * Copyright © 2012,2014 Canonical Ltd.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 3 as
@@ -54,3 +54,27 @@
     EXPECT_EQ(X(x), p.x);
     EXPECT_EQ(Y(y), p.y);
 }
+
+TEST(geometry, point_can_be_scaled)
+{
+    using namespace geom;
+    int x = 2;
+    int y = 4;
+    auto p1 = 2.0f * Point{x, y};
+    auto p2 = Point{x, y} * 3.5f;
+    EXPECT_EQ(X(x*2), p1.x);
+    EXPECT_EQ(Y(y*2), p1.y);
+    EXPECT_EQ(X(7), p2.x);
+    EXPECT_EQ(Y(14), p2.y);
+}
+
+TEST(geometry, point_can_be_scaled_with_div)
+{
+    using namespace geom;
+    int x = 12;
+    int y = 6;
+    auto p1 = Point{x, y}/3.0f;
+    EXPECT_EQ(X(x/3), p1.x);
+    EXPECT_EQ(Y(y/3), p1.y);
+}
+

=== added file 'tests/unit-tests/geometry/test-transformation.cpp'
--- tests/unit-tests/geometry/test-transformation.cpp	1970-01-01 00:00:00 +0000
+++ tests/unit-tests/geometry/test-transformation.cpp	2014-03-19 14:02:20 +0000
@@ -0,0 +1,247 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Andreas Pokorny <[e-mail]>
+ */
+
+#include "mir/geometry/transformation.h"
+
+#include <gtest/gtest.h>
+
+#define GLM_FORCE_RADIANS
+#include "glm/gtx/euler_angles.hpp"
+#include "glm/gtx/transform.hpp"
+
+namespace geom = mir::geometry;
+
+::testing::AssertionResult MatricesMatch(glm::mat4 const& expected, glm::mat4 const& tested)
+{
+    for (int i = 0; i != 4; ++i)
+    {
+        for (int j = 0; j != 4; ++j)
+        {
+            float diff = std::abs(expected[i][j] - tested[i][j]);
+            if (diff > 1.0E-7f)
+            {
+                return ::testing::AssertionFailure() << "item (" << i << ", "<< j << ") differs:"
+                    << tested[i][j] << " instead of " << expected[i][j] << " off by " << diff;
+            }
+        }
+    }
+
+    return ::testing::AssertionSuccess();
+}
+
+namespace
+{
+
+glm::vec4 to_vec4(geom::Point const& p)
+{
+    return glm::vec4{p.x.as_float(), p.y.as_float(), 0.0f, 1.0f};
+}
+
+geom::Point to_point(glm::vec4 const& p)
+{
+    return {std::round(p.x), std::round(p.y)};
+}
+
+}
+
+TEST(geometry_transformation, identity_on_creation)
+{
+    using namespace geom;
+    Transformation identity;
+    EXPECT_TRUE(identity.is_identity());
+    EXPECT_FALSE(identity.is_translation());
+    EXPECT_FALSE(identity.is_scaling_translation());
+    EXPECT_EQ(1.0f, identity.get_scale());
+    EXPECT_EQ(0.0f, identity.get_z_rotation());
+    EXPECT_EQ(0.0f, identity.get_x_rotation());
+    EXPECT_EQ(0.0f, identity.get_y_rotation());
+    EXPECT_EQ(geom::Displacement(), identity.get_translation());
+}
+
+TEST(geometry_transformation, scale_may_destroy_identity)
+{
+    using namespace geom;
+    Transformation identity;
+    identity.set_scale(1230.f);
+    EXPECT_FALSE(identity.is_identity());
+    EXPECT_FALSE(identity.is_scaling_translation());
+    EXPECT_TRUE(identity.is_scaling());
+    identity.set_scale(1.0f);
+    EXPECT_TRUE(identity.is_identity());
+}
+
+TEST(geometry_transformation, translation)
+{
+    using namespace geom;
+    Transformation movement;
+    movement.set_translation(geom::Displacement{13,14});
+    EXPECT_TRUE(movement.is_translation());
+    EXPECT_FALSE(movement.is_scaling_translation());
+    EXPECT_FALSE(movement.requires_matrix_transformation());
+    EXPECT_TRUE(movement.is_translation());
+
+    geom::Displacement mov{13,14};
+    EXPECT_EQ(mov, movement.get_translation());
+}
+
+TEST(geometry_transformation, identity_matrices)
+{
+    using namespace geom;
+    Transformation identity;
+    glm::mat4 expected;
+    EXPECT_TRUE(MatricesMatch(expected, identity.get_matrix()));
+    EXPECT_TRUE(MatricesMatch(expected, identity.get_inverse_matrix()));
+    EXPECT_TRUE(MatricesMatch(expected, identity.get_center_matrix()));
+
+    Point test_p(4124,1231);
+    EXPECT_EQ(test_p, identity.transform_to_local(test_p));
+    EXPECT_EQ(test_p, identity.transform_to_screen(test_p));
+    EXPECT_EQ(test_p, to_point(identity.get_matrix() * to_vec4(test_p)));
+    EXPECT_EQ(test_p, to_point(identity.get_inverse_matrix() * to_vec4(test_p)));
+}
+
+TEST(geometry_transformation, translation_matrices)
+{
+    using namespace geom;
+    Transformation translation;
+    Displacement amount{13,42};
+    translation.set_translation(amount);
+    glm::mat4 expected_center, expected;
+
+    expected[3] = glm::vec4{amount.dx.as_float(), amount.dy.as_float(), 0.0f, 1.0f};
+
+    EXPECT_TRUE(MatricesMatch(expected, translation.get_matrix()));
+    EXPECT_TRUE(MatricesMatch(glm::inverse(expected), translation.get_inverse_matrix()));
+    EXPECT_TRUE(MatricesMatch(expected_center, translation.get_center_matrix()));
+
+    Point test_p(4124, 1147);
+    Point screen_p(4137, 1189);
+    EXPECT_EQ(screen_p, translation.transform_to_screen(test_p));
+    EXPECT_EQ(test_p, translation.transform_to_local(screen_p));
+    EXPECT_EQ(screen_p, to_point(translation.get_matrix() * to_vec4(test_p)));
+    EXPECT_EQ(test_p, to_point(translation.get_inverse_matrix() * to_vec4(screen_p)));
+}
+
+TEST(geometry_transformation, scaling_matrices)
+{
+    using namespace geom;
+    Transformation scaling{Size{120,60}};
+    scaling.set_scale(3.5f);
+    glm::mat4 inv_expected, expected;
+    expected[0].x = expected[1].y = expected[2].z = 3.5f;
+    inv_expected[0].x = inv_expected[1].y = inv_expected[2].z = 1.0f/3.5f;
+
+    EXPECT_TRUE(MatricesMatch(expected, scaling.get_matrix()));
+    EXPECT_TRUE(MatricesMatch(expected, scaling.get_center_matrix()));
+    EXPECT_TRUE(MatricesMatch(inv_expected, scaling.get_inverse_matrix()));
+
+    Point test_p(10, 20);
+    Point screen_p(35, 70);
+    EXPECT_EQ(screen_p, scaling.transform_to_screen(test_p));
+    EXPECT_EQ(test_p, scaling.transform_to_local(screen_p));
+    EXPECT_EQ(screen_p, to_point(scaling.get_matrix() * to_vec4(test_p)));
+    EXPECT_EQ(test_p, to_point(scaling.get_inverse_matrix() * to_vec4(screen_p)));
+}
+
+TEST(geometry_transformation, scale_and_translate_matrices)
+{
+    using namespace geom;
+    Transformation scale_and_translate{Size{30,10}};
+    float scale = 1.33f;
+    float x_pos = 60.0f;
+    float y_pos = 50.0f;
+    scale_and_translate.set_scale(scale);
+    scale_and_translate.set_translation(Displacement{x_pos, y_pos});
+    glm::mat4 inv_expected, expected;
+    expected[0].x = expected[1].y = expected[2].z = scale;
+    expected[3].x = x_pos;
+    expected[3].y = y_pos;
+    inv_expected = glm::scale(glm::vec3(1.0f/scale))* glm::translate(-glm::vec3{x_pos,y_pos,0});
+
+    EXPECT_TRUE(MatricesMatch(expected, scale_and_translate.get_matrix()));
+    EXPECT_TRUE(MatricesMatch(inv_expected, scale_and_translate.get_inverse_matrix()));
+
+    Point test_p(10, 20);
+    Point screen_p(73, 77);
+    EXPECT_EQ(screen_p, scale_and_translate.transform_to_screen(test_p));
+    EXPECT_EQ(test_p, scale_and_translate.transform_to_local(screen_p));
+    EXPECT_EQ(screen_p, to_point(scale_and_translate.get_matrix() * to_vec4(test_p)));
+    EXPECT_EQ(test_p, to_point(scale_and_translate.get_inverse_matrix() * to_vec4(screen_p)));
+}
+
+TEST(geometry_transformation, rotate_by_90_matrices)
+{
+    using namespace geom;
+    Transformation rotation(Size(10,10));
+    rotation.set_rotation(90.0f);
+    glm::mat4 expected_center;
+    expected_center[0] = glm::vec4{0.0f, 1.0f, 0.0f, 0.0f};
+    expected_center[1] = glm::vec4{-1.0f, 0.0f, 0.0f, 0.0f};
+    glm::mat4 expected_matrix = expected_center;
+    expected_matrix[3] = glm::vec4{10.0f, 0.0f, 0.0f, 1.0f};
+    glm::mat4 expected_inverse = glm::inverse(expected_matrix);
+
+    EXPECT_TRUE(MatricesMatch(expected_matrix, rotation.get_matrix()));
+    EXPECT_TRUE(MatricesMatch(expected_center, rotation.get_center_matrix()));
+    EXPECT_TRUE(MatricesMatch(expected_inverse, rotation.get_inverse_matrix()));
+
+    Point test_p(0, 0);
+    Point screen_p(10, 0);
+    EXPECT_EQ(screen_p, rotation.transform_to_screen(test_p));
+    EXPECT_EQ(test_p, rotation.transform_to_local(screen_p));
+    EXPECT_EQ(screen_p, to_point(rotation.get_matrix() * to_vec4(test_p)));
+    EXPECT_EQ(test_p, to_point(rotation.get_inverse_matrix() * to_vec4(screen_p)));
+}
+
+TEST(geometry_transformation, all_combined_matrices)
+{
+    using namespace geom;
+    glm::vec3 center(10,5,0);
+    float angle = 20.0f;
+    float scale = 3.65f;
+    glm::vec3 translation(100,100,0);
+
+    Transformation all_combined(Size(center.x*2,center.y*2));
+    all_combined.set_rotation(angle);
+    all_combined.set_scale(scale);
+    all_combined.set_translation(Displacement(translation.x,translation.y));
+
+    glm::mat4 expected =
+        glm::translate(translation) *
+        glm::scale(glm::vec3(scale)) *
+        glm::translate(center) *
+        glm::eulerAngleZ(glm::radians(angle)) *
+        glm::translate(-center);
+
+    glm::mat4 inverse =
+        glm::translate(center) *
+        glm::eulerAngleZ(glm::radians(-angle)) *
+        glm::translate(-center) *
+        glm::scale(glm::vec3(1.0f / scale)) *
+        glm::translate(-translation);
+
+    EXPECT_TRUE(MatricesMatch(expected, all_combined.get_matrix()));
+    EXPECT_TRUE(MatricesMatch(inverse, all_combined.get_inverse_matrix()));
+
+    Point test_p(20, 10);
+    Point screen_p(165, 148);
+    EXPECT_EQ(screen_p, all_combined.transform_to_screen(test_p));
+    EXPECT_EQ(test_p, all_combined.transform_to_local(screen_p));
+    EXPECT_EQ(screen_p, to_point(all_combined.get_matrix() * to_vec4(test_p)));
+    EXPECT_EQ(test_p, to_point(all_combined.get_inverse_matrix() * to_vec4(screen_p)));
+}