Re: [eigen] Transform products

[Benoit Jacob <jacob.benoit.1@xxxxxxxxx>]

Hi,

I think the following question needs to be adressed first: couldn't we
just assume that the last row is 0,...,0,1 ? Is there really any use
case for non-affine transformations? Thus the last row would be there
just for seamless interoperability with OpenGL.

Or do you have a real use case where the last row is not 0,...,0,1 ?

Cheers,
Benoit

2009/2/19 Gael Guennebaud <gael.guennebaud@xxxxxxxxx>:
> Hi list,
>
> there still remains a few issues with the product: Transform * matrix_expression
>
> Let d be the dimension of the ambient space (so that the Transform
> object actually correspond to a d+1 x d+1 matrix). Currently we allow:
>
> 1 - Transform * [d x d] => Transform
> 2 - Transform * [d+1 x d+1] => trivial product expression
> 3 - Transform * [d+1 x 1] => trivial product expression
> 4 - Transform * [d x 1] => complex [d x 1] expression including the
> homogeneous normalization
>
> Issues:
>
> a) the 4-th case is not plenty satisfactory:
>
>  a1 - should it returns an homogeneous vector ?
>  a2 - or automatically does the normalization as it currently does ?
>  a3 - or should we offer a way to skip the normalization assuming the
> transformation is affine (last row = [0 ... 0 1]) ?
>
> Well, these questions are more complementary and I guess the answer is
> yes for all, the problem is rather how to expose all these variants ?
> a proposal:
>
> for a3 let's add "t.affine() * v"   where affine() would return  a
> kind of [d x d+1] proxy with overloaded operator *.
>
> for a1 and a2, two options:
>
>  p1) keep the default as it because it is safe
>       and for a1... well I don't know, anyway the user can still
>       build and homogeneous one for the rhs.
>
>  p2) let's return a "homogeneous" object which would
>      automatically be converted to a [d x 1] vector if needed
>      (ideally would have to be done in MatrixBase)
>
>
>
> b) second issue: We want to be able to perform a batch transformation
> of a set of N vectors. Again two cases:
>
>  b1 - Transform * [d+1 x N] => this is trivial, we just have to merge
> the above cases 1 and 2 into a more generic one. DONE
>
>  b2 - Transform * [d x N]  =>  same issues than the ones discussed
> above excepted that the involved expressions are much more complicated
> ! For instance the affine case would be:
>  t.matrix().linear() * [d x N] + t.matrix().translation() *
> Matrix<Scalar,d,N>::Ones(N);
>
> This last example also shows that maybe it would be useful to have a
> "replicate" expression mapping a vector to a matrix with constant rows
> or constant columns ? This would be simpler than using a matrix
> product for that.
>
> And of course all the above discussion also holds for the transpose
> cases, i.e., matrix_expression * Transform.
>
>
> opinion, idea ?
>
> thanks,
> Gael.
>
>
>