[enkimute]

Ok, standard 4x4 matrices also implement a projective (aka d+1) model. (the 'w' coordinate is just the projective coordinate). So no difference with GA in that respect.

Setting up a unified transformation hierarchy is actually very easy, and again not really different from how you would approach it with matrices. (plus, its more performant). Simply swap the matrix with the appropriate versor.

Which (versors or matrices) are appropriate depends on the symmetry group you are interested in :

Orthogonal Group (just rotations : distance + origin preserving) in d dimensions -> use the geometric algebra R_d. (classically : complex numbers, quaternions)

Lorentz Group (rotations + boosts : spacetime distance + origin preserving) in d space dimensions and 1 time dimension -> use the geometric algebra R_{d,1}. (classically : Lorentz transformations)

Euclidean Group (translations + rotations : distance preserving) in d dimensions -> use the geometric algebra R_{d,0,1}. (classically : planar quaternions, dual quaternions)

Conformal Group (translations + rotations + dilations : angle preserving) -> use the geometric algebra R_{d+1,1}. (classically : linear fractional transformations)

General Linear Group (translations + rotations + sheering + ... : preserves parallelism/incidence) : use d+1 x d+1 matrices.

Working in a symmetry group that is 'to big' comes at a cost - both in algorithmic complexity as well as numerical precision. If you only want translations/rotations, but are using matrices you'll have to resort to things like Gramm-Shmidt or SVD to re-orthogonalize your matrices after doing numerical calculations. (you have to project it back to the solution manifold in math terms - this is almost never trivial and often impossible).

(for those interested, I explain this in-depth in my GAME2020 talk : https://www.youtube.com/watch?v=ichOiuBoBoQ&ab_channel=Bivec... )

[hohohmm]

Thanks for the information.

It's nice of you to point out that 4x4 matrix is projective in nature, and I understand that GA could potentially be more performant for its more compact usage of numbers.

But to really make it popular and understandable, a "simple" version of GA that handles translation, rotation & non-uniform scaling would really help, without the group thoery concepts, even better, make it in the context of a scene graph hiearchy, with a unified operator like "multiply".

Also is it possible to collapse a series of such transforms in a single versor like you can do with matrices without going into dual quaternion stuff? In generic game developemnt, translation, rotation, and non-uniform scaling are all extremely basic things that cannot be handwaved away or "too big".

Also, why the need o a dual(e12, e02, e01) to represent a point when in vector it's just a (e0, e1, e2). This is just counterinuitive. This is what I mean by "quickly gets complicated" and it feels nearly as opaque as cross product in vector math.

Just explaining my experience digging in GA for a couple of weeks.

[DougBTX]

> Also, why the need o a dual(e12, e02, e01) to represent a point when in vector it's just a (e0, e1, e2). This is just counterinuitive.

It seems like it isn't needed, but it hasn't all been wrapped up into an easy to understand package yet:

http://terathon.com/blog/projective-geometric-algebra-done-r...

http://terathon.com/blog/symmetries-in-projective-geometric-...

[layoutIfNeeded]

>a "simple" version of GA that handles translation, rotation & non-uniform scaling would really help

I think once you include non-uniform scaling you’d be best off with 4x4 matrices. Or @enkimute might be aware of better solutions via GA...

[enkimute]

That is correct - matrices are the natural companion of the general linear group. The GA representation exists, and is called 'the mother algebra', for general 4x4 matrices the GA equivalent is R4,4. (where general linear transformations are versors).

For other subgroups GA reps will also exist. (like e.g. if one wants to include projective transformations as versors, that would be the projective group (which preserves the cross ratio of 4 points), and has a GA representation in R3,3).

These spaces quickly become so big that efficient numerical implementations (while not impossible with enough symbolic work at compilation time, see e.g. https://www.jeremyong.com/gal/) are difficult. Other advantages of GA do of course remain.

[enkimute]

> But to really make it popular and understandable, a "simple" version of GA that handles translation, rotation & non-uniform scaling would really help, without the group theory concepts, even better, make it in the context of a scene graph hiearchy, with a unified operator like "multiply".

The rich structure of GA (that ultimately follows from just one axiom extra) unifies a wide range of concepts and theories. Considering just one application, or one link, puts one at risk of arriving at a model that breaks these connections to other parts of mathematics. It seems unfair to expect to understand the why without considering the connections to Lie Groups, their associated geometries, differential forms, etc.

That said, I have some unpublished examples displaying and processing bvh (mocap) files that I'll try to cleanup and put online.

> Also is it possible to collapse a series of such transforms in a single versor like you can do with matrices without going into dual quaternion stuff? In generic game developemnt, translation, rotation, and non-uniform scaling are all extremely basic things that cannot be handwaved away or "too big".

Versors combine just like matrices (using just the ordinary product). (doing this for translations/rotations _are_ the dual quaternions, but you don't have to (and imho shouldn't) call them that.). Non-uniform scaling along your scenegraph (as opposed to in the beginning (object space) or at the end (view space)) is usually frowned upon in professional game development. (it makes it impossible to correct matrices using Gramm-Shmidt, and adds a lot of complexity to things like tracing hit rays etc).

> Also, why the need o a dual(e12, e02, e01) to represent a point when in vector it's just a (e0, e1, e2). This is just counterinuitive. This is what I mean by "quickly gets complicated" and it feels nearly as opaque as cross product in vector math.

This is because geometry and group theory are intricately connected. When you use matrices, you represent elements with vectors and transformations with matrices - they're separate things. In Geometric Algebra, every element also _is_ a transformation. (a plane represents a reflection in that plane, a line represents a 180 degree rotation around that line, a point represents a point reflection in that point). So now there is a strong link. Whatever you use to represent reflections should also represent planes, same for rotations/translations and lines, or point reflections and points.

It is in fact very intuitive and simple, its just different from what you're used to. For example, in 2D, given a point at euclidean position (3,4), here are the two mindsets:

* classic : it is a sum of three times the 'x' vector and 4 times the 'y' vector. (and actually than add in '1' homogeneous vector). '3x + 4y + w' (in memory : 3,4,1 )

* GA : (3,4) is a system of equations. Namely 'x=3' and 'y=4', or homogeneously : 'x-3=0' and 'y-4=0'. Such homogeneous linear equations are lines (in 2D), and represented by vectors : 'e1-3e0' and 'e2-4e0', solving such a system of equations is just the outer product: '(e1-3e0) ^ (e2 - 4e0) = 3e20 + 4e01 + e12'. (in memory : 3,4,1)

so because it is on the bivector basis, this element (3e20 + 4e01 + e12) now represents both the point at (3,4) as well as a rotation of 180 degrees around that point. Just like the line (e1-3*e0) represents both the line `x=3` as well as a reflection w.r.t. that line. For the same reason the product of two lines will give you the rotation or translation between them and the product of two points will always give you the translation.

So I'd argue its a lot more intuitive, don't factor out the time it took you to find the linear algebra approach intuitive.

[hohohmm]

Thanks for the explanations. Just want to elaborate on this point:

>> Also is it possible to collapse a series of such transforms in a single versor like you can do with matrices without going into dual quaternion stuff? In generic game developemnt, translation, rotation, and non-uniform scaling are all extremely basic things that cannot be handwaved away or "too big".

>Versors combine just like matrices (using just the ordinary product). (doing this for translations/rotations _are_ the dual quaternions, but you don't have to (and imho shouldn't) call them that.). Non-uniform scaling along your scenegraph (as opposed to in the beginning (object space) or at the end (view space)) is usually frowned upon in professional game development. (it makes it impossible to correct matrices using Gramm-Shmidt, and adds a lot of complexity to things like tracing hit rays etc).

Though frowned upon, it's important to retain the ability to do non-linear scales, as that's part of tuning things in-engine fast. It could be later corrected but without it, it becomes very cumbersome to do quick tunings of object scales or maybe simply doing quick scene mockups. I work in games in a professional capacity and find this usage very common and almost indispensible.

[cygx]

> this element (3e20 + 4e01 + e12) now represents [...] the point at (3,4)

Note that this is just the Hodge dual of (3e1 + 4e2 + e0), or, as you labelled it previously, (3x + 4y + w)...

[enkimute]

Absolutely :

Algebraically we can always use the Hodge dual and its inverse to move to/from k-vectors from/to n-k vectors.

Geometrically we can always say two points define a line or two lines define a point.

Group Theory - here we can't swap. Two reflections make a rotation but two rotations do not make a reflection. So reflections are 'naturally' grade 1.

If you want everything to fit intuitively together, you want reflections to be grade 1, and by consequence hyperplanes (lines in 2D, planes in 3D, etc) to be grade 1 (i.e. vectors).

Doing it the other way around is possible but will be more verbose and less intuitive. (also with 'reflections' as natural grade 1 elements, the move from Euclidean to Conformal becomes trivial, simply reflect in (hyper)spheres instead, in this space it is also easier to see that the two approaches are not equivalent, it is natural to say that (in 2D) the 'meet' of two circles is a point pair, but not that the 'join' of two points is a point pair. (why would it not be a line just like in PGA?)).

Imho, one should learn to appreciate both halves of the picture, as for each specific problem one of them might be more natural. (for the popular Euclidean group and its associated geometry this view we're not used to may very well be more intuitive one, imho).

[cygx]

Isn't this just a consequence of phrasing things in terms of the wedge product instead of its 'pullback' via the Hodge? Because personally, I think the most natural representation of a reflection is the mirror plane, not its normal vector...

[enkimute]

The grade 1 element is not the normal vector of the plane, it is the plane itself (as a homogeneous linear form, it includes the distance from the origin as an extra coefficient, which the normal vector does not).

Linear equations form a linear space, you can add them and multiply them with scalars. (creating things called line-pencils, plane-bundles etc .. classic projective geometry). Hence you call the grade-1 elements of the graded version of such a linear space 'vectors'. (just like you can make vector spaces with functions or all other sorts of objects).

So the reflection formula from GA in general, which is to reflect an arbitrary element X w.r.t. a grade-1 element a :

-aXa

is simply to be read as reflecting the object 'X' in the plane (3D) or line (2D) or sphere (3D CGA) or circle (2D CGA) 'a'.

Such a reflection should modify all other reflections, except for itself (where it should only flip orientation) :

-aaa = -a

It is easy to verify that this holds for general Euclidean planes written as homogeneous linear equations in their grade-1 element form. And from that everything else follows. (composition of reflections gives you rotations/translations (leaving points invariant in 2D), etc).

Planes being grade 1 elements in no way implies characterizing them by a normal vector.

[gugagore]

Despite the costs of using a “too big” symmetry group (I’d say overparameterization), I bet it’s hard to beat the performance of 4*4 matrix multiplications, since the computation is so uniform, vectorizable, and perfectly sized for e.g. SIMD. Even if there are fewer math operations with another representation.

[banachtarski]

It depends. For composing multiple transforms, composing versors aka quaternions/dual quaternions is cheaper than a full 4x4 multiply. For a single application, a 4x4 will be cheaper.

[gugagore]

Without benchmarks, I do not trust you. :) have you tried? On what platform? And did you take a look at the assembly code?

[enkimute]

Take a look at Klein : https://www.jeremyong.com/klein/ (arm implementation is coming)

Its geometric product between motors is the equivalent of the 4x4 matrix product.

Although the basic computational complexity tells the story :

4x4 matrix product : 16 floats storage, 64 multiplies, 48 additions.

3D PGA versor product : 8 floats storage, 48 multiplies, 40 additions.

[banachtarski]

Quaternions are used in animation for blending and composing transforms for a reason. You don't have to trust me, but yes... tried for maybe ten years and counting from doing graphics and animation work.

[chombier]

From the documentation of the Eigen library [0]:

> If the quaternion is used to rotate several points (>1) then it is much more efficient to first convert it to a 3x3 Matrix. Comparison of the operation cost for n transformations:

> - Quaternion2: 30n

> - Via a Matrix3: 24 + 15n

So really it depends on what you're doing (admittedly here it is 3x3 not 4x4)

[0] https://eigen.tuxfamily.org/dox/classEigen_1_1QuaternionBase...

[banachtarski]

Right, as I said, composition is faster, not application.