You can subscribe to this list here.
2000 
_{Jan}

_{Feb}

_{Mar}

_{Apr}

_{May}

_{Jun}

_{Jul}
(390) 
_{Aug}
(767) 
_{Sep}
(940) 
_{Oct}
(964) 
_{Nov}
(819) 
_{Dec}
(762) 

2001 
_{Jan}
(680) 
_{Feb}
(1075) 
_{Mar}
(954) 
_{Apr}
(595) 
_{May}
(725) 
_{Jun}
(868) 
_{Jul}
(678) 
_{Aug}
(785) 
_{Sep}
(410) 
_{Oct}
(395) 
_{Nov}
(374) 
_{Dec}
(419) 
2002 
_{Jan}
(699) 
_{Feb}
(501) 
_{Mar}
(311) 
_{Apr}
(334) 
_{May}
(501) 
_{Jun}
(507) 
_{Jul}
(441) 
_{Aug}
(395) 
_{Sep}
(540) 
_{Oct}
(416) 
_{Nov}
(369) 
_{Dec}
(373) 
2003 
_{Jan}
(514) 
_{Feb}
(488) 
_{Mar}
(396) 
_{Apr}
(624) 
_{May}
(590) 
_{Jun}
(562) 
_{Jul}
(546) 
_{Aug}
(463) 
_{Sep}
(389) 
_{Oct}
(399) 
_{Nov}
(333) 
_{Dec}
(449) 
2004 
_{Jan}
(317) 
_{Feb}
(395) 
_{Mar}
(136) 
_{Apr}
(338) 
_{May}
(488) 
_{Jun}
(306) 
_{Jul}
(266) 
_{Aug}
(424) 
_{Sep}
(502) 
_{Oct}
(170) 
_{Nov}
(170) 
_{Dec}
(134) 
2005 
_{Jan}
(249) 
_{Feb}
(109) 
_{Mar}
(119) 
_{Apr}
(282) 
_{May}
(82) 
_{Jun}
(113) 
_{Jul}
(56) 
_{Aug}
(160) 
_{Sep}
(89) 
_{Oct}
(98) 
_{Nov}
(237) 
_{Dec}
(297) 
2006 
_{Jan}
(151) 
_{Feb}
(250) 
_{Mar}
(222) 
_{Apr}
(147) 
_{May}
(266) 
_{Jun}
(313) 
_{Jul}
(367) 
_{Aug}
(135) 
_{Sep}
(108) 
_{Oct}
(110) 
_{Nov}
(220) 
_{Dec}
(47) 
2007 
_{Jan}
(133) 
_{Feb}
(144) 
_{Mar}
(247) 
_{Apr}
(191) 
_{May}
(191) 
_{Jun}
(171) 
_{Jul}
(160) 
_{Aug}
(51) 
_{Sep}
(125) 
_{Oct}
(115) 
_{Nov}
(78) 
_{Dec}
(67) 
2008 
_{Jan}
(165) 
_{Feb}
(37) 
_{Mar}
(130) 
_{Apr}
(111) 
_{May}
(91) 
_{Jun}
(142) 
_{Jul}
(54) 
_{Aug}
(104) 
_{Sep}
(89) 
_{Oct}
(87) 
_{Nov}
(44) 
_{Dec}
(54) 
2009 
_{Jan}
(283) 
_{Feb}
(113) 
_{Mar}
(154) 
_{Apr}
(395) 
_{May}
(62) 
_{Jun}
(48) 
_{Jul}
(52) 
_{Aug}
(54) 
_{Sep}
(131) 
_{Oct}
(29) 
_{Nov}
(32) 
_{Dec}
(37) 
2010 
_{Jan}
(34) 
_{Feb}
(36) 
_{Mar}
(40) 
_{Apr}
(23) 
_{May}
(38) 
_{Jun}
(34) 
_{Jul}
(36) 
_{Aug}
(27) 
_{Sep}
(9) 
_{Oct}
(18) 
_{Nov}
(25) 
_{Dec}

2011 
_{Jan}
(1) 
_{Feb}
(14) 
_{Mar}
(1) 
_{Apr}
(5) 
_{May}
(1) 
_{Jun}

_{Jul}

_{Aug}
(37) 
_{Sep}
(6) 
_{Oct}
(2) 
_{Nov}

_{Dec}

2012 
_{Jan}

_{Feb}
(7) 
_{Mar}

_{Apr}
(4) 
_{May}

_{Jun}
(3) 
_{Jul}

_{Aug}

_{Sep}
(1) 
_{Oct}

_{Nov}

_{Dec}
(10) 
2013 
_{Jan}

_{Feb}
(1) 
_{Mar}
(7) 
_{Apr}
(2) 
_{May}

_{Jun}

_{Jul}
(9) 
_{Aug}

_{Sep}

_{Oct}

_{Nov}

_{Dec}

2014 
_{Jan}
(14) 
_{Feb}

_{Mar}
(2) 
_{Apr}

_{May}
(10) 
_{Jun}

_{Jul}

_{Aug}

_{Sep}

_{Oct}

_{Nov}
(3) 
_{Dec}

2015 
_{Jan}

_{Feb}

_{Mar}

_{Apr}

_{May}

_{Jun}

_{Jul}

_{Aug}

_{Sep}

_{Oct}
(12) 
_{Nov}

_{Dec}
(1) 
2016 
_{Jan}

_{Feb}
(1) 
_{Mar}
(1) 
_{Apr}
(1) 
_{May}

_{Jun}
(1) 
_{Jul}

_{Aug}
(1) 
_{Sep}

_{Oct}

_{Nov}

_{Dec}

S  M  T  W  T  F  S 

1
(5) 
2
(9) 
3
(1) 
4
(2) 
5

6
(3) 
7

8

9

10
(1) 
11
(3) 
12

13
(4) 
14

15

16
(2) 
17
(7) 
18
(3) 
19
(5) 
20
(1) 
21

22

23

24
(1) 
25
(7) 
26
(9) 
27
(3) 
28

29
(1) 
30
(10) 
31
(5) 




From: Alex Mohr <amohr@cs...>  20050513 20:25:25

>The idea behind the solution discussed in the article is that if we >can somehow minimise our objective function in SO(3) _directly_  >there is no need for the constraints at all. The problem then turns >into one that can be solved by quadratic programming! Just to say it again, for the original problem of finding the 'optimal' rigid transformation between corresponded point clouds, if you're okay with the error metric being a leastsquares thing, you can get away with doing an SVD. Easy to code and stable, robust, etc. I strongly recommend against doing nonlinear optimization for this. Alex 
From: Per Vognsen <Per.V<ognsen@ep...>  20050513 18:52:08

> Original Message > From: gdalgorithmslistadmin@... [mailto:gdalgorithms > listadmin@...] On Behalf Of Willem de Boer > Sent: Friday, May 13, 2005 7:30 AM > To: gdalgorithmslist@... > Subject: [Algorithms] Finding optimal transformations >=20 > Everyone, >=20 > In light of a recent discussion on finding a single > Euclidean transformation that "optimally" transforms a > set of points onto another set of the same size, I > recently found a nice little article that some of > the people on this list might find interesting. >=20 > It can be found at: >=20 > http://www.cis.upenn.edu/~cjtaylor/publications/Minimization.pdf >=20 > Consider the problem where we have to find a rotation > matrix that "optimally" rotates a set of points onto > another set. The usual way of going about solving this > is to use some kind of _constrained_ optimisation > algorithm. The constraints are that the matrix be > orthogonal and have determinant 1. SO(n) is a nonsingular affine variety in R^(n^2) so you can use Lagrange multipliers to solve optimization problems on it. The same goes for essentially all the other matrix Lie groups people are interested in. Even slightly funky ones like SE(3) can be handled this way. Recall that SE(3) as a Lie group splits as the semidirect product of R^3 and SO(3). As a differential manifold SE(3) is just the product of R^3 and SO(3), and thus the Jacobian splits in a natural way into the Jacobians of the factors. So optimization on SE(3) is just "simultaneous optimization" on R^3 and SO(3). > The idea behind the solution discussed in the article > is that if we can somehow minimise our objective > function in SO(3) _directly_  there is no need for > the constraints at all. The problem then turns into > one that can be solved by quadratic programming! Quadratic programming is pretty hardcore. Even special cases like convex quadratic programming are darn tricky. Certainly this is a nice geometric way to look at the problem but I think there are probably easier, more efficient algorithms in practice. If you are interested in areas where the theory of Lie groups and algebras can be applied to game development, it is worth looking into "geometric integration". It is the application of Lie algebra techniques to the numerical solution of ODEs on Lie groups. For instance, the dynamics of a rigid body are really the dynamics of a point on SO(3) satisfying the NewtonEuler equations of motion. Usually these are numerically integrated forward in time by regarding a point in SO(3) by its embedding in R^(3x3). If you start with a point on SO(3) and use such a scheme to integrate the point forward in time, you will generally wind up with a point that is no longer on SO(3). The theory of geometric integration instead looks at the corresponding equations of motion on the Lie algebra of SO(3) and "linearizes" them there. The update delta is computed in the Lie algebra and then lifted to the Lie group via the exponential map. The lifted delta is then multiplied onto the point, giving another point of SO(3) since it is closed under multiplication. It turns out that there are integration schemes on the Lie algebra corresponding to RungeKutta, etc. It's all very pretty and some of it is even useful. :) Cheers, Per 
From: PeterPike Sloan <ppsloan@wi...>  20050513 17:46:16

For the problem posted the other methods are superior  they are much simpler than solving a constrained nonlinear optimization problem. The technique presented in the paper is similar to trust region based methods in nonlinear optimization also. It is also possible to solve these (and other problems on these manifolds) using lagrange multipliers and unconstrained nonlinear optimization, which isn't that terrible (still much worse than the techniques in the other thread.) I've done this both on the sphere in R3 and R4 to generalize "weighted averages" for blending points on the sphere or unit quaternions (the weighted average of a set of vectors is the "X" that minimizes the function sum_i(w_i*Distance(P_i,X)^2) in euclidean space (*), replace the distance function with distance over the manifold and you generalize slerp...) The technique only finds a local minimum, which I think might not be a problem for the particular problem, but can be a problem in general. =20 It is an interesting paper though. PeterPike (*) the proof of this is very simple, Distance(A,B)^2 =3D dot(AB,AB), minimize the sum above (wrt X), the second derivative is always positive, so just solve the first derivative for zero. =20 Err(X) =3D sum_i(w_i*sum_j( (P_ijX_j)^2 ) ) The derivative is: dErr/dj =3D sum_i(2*w_i*(X_jP_ij)) Solving equal to zero (each dimension is independent), you get X_j =3D sum_i(w_i*P_ij)/sum_i(w_i) Which is just the weighted average (if the weights sume to 1). Original Message From: gdalgorithmslistadmin@... [mailto:gdalgorithmslistadmin@...] On Behalf Of Willem de Boer Sent: Friday, May 13, 2005 4:30 AM To: gdalgorithmslist@... Subject: [Algorithms] Finding optimal transformations Everyone, In light of a recent discussion on finding a single Euclidean transformation that "optimally" transforms a set of points onto another set of the same size, I recently found a nice little article that some of the people on this list might find interesting. It can be found at: http://www.cis.upenn.edu/~cjtaylor/publications/Minimization.pdf Consider the problem where we have to find a rotation matrix that "optimally" rotates a set of points onto another set. The usual way of going about solving this is to use some kind of _constrained_ optimisation algorithm. The constraints are that the matrix be orthogonal and have determinant 1. The idea behind the solution discussed in the article is that if we can somehow minimise our objective function in SO(3) _directly_  there is no need for the constraints at all. The problem then turns into one that can be solved by quadratic programming! THE COOL THING IS: The cool thing is that this doesn't just work for SO(3) only. The authors give a few examples of where we can translate a constrained optimisation problem into an unconstrained one in SO(3). For example, it is also possible to optimise functions defined on the unit sphere this way! The reason all this works is due to some results in matrix Lie group theory, an introduction to which can be found in the book "Lie Groups, Lie algebras and representations" by Brian C. Hall. It is highly recommended. Cheers,  Willem H. de Boer Homepage: http://www.whdeboer.com=20  This SF.Net email is sponsored by Oracle Space Sweepstakes Want to be the first software developer in space? Enter now for the Oracle Space Sweepstakes! http://ads.osdn.com/?ad_ids93&alloc_id=16281&op=3Dick _______________________________________________ GDAlgorithmslist mailing list GDAlgorithmslist@... https://lists.sourceforge.net/lists/listinfo/gdalgorithmslist Archives: http://sourceforge.net/mailarchive/forum.php?forum_ida88 
From: Willem de Boer <wdeboer@pl...>  20050513 11:30:43

Everyone, In light of a recent discussion on finding a single Euclidean transformation that "optimally" transforms a set of points onto another set of the same size, I=20 recently found a nice little article that some of the people on this list might find interesting. It can be found at: http://www.cis.upenn.edu/~cjtaylor/publications/Minimization.pdf Consider the problem where we have to find a rotation matrix that "optimally" rotates a set of points onto another set. The usual way of going about solving this is to use some kind of _constrained_ optimisation algorithm. The constraints are that the matrix be orthogonal and have determinant 1. The idea behind the solution discussed in the article is that if we can somehow minimise our objective function in SO(3) _directly_  there is no need for the constraints at all. The problem then turns into one that can be solved by quadratic programming! THE COOL THING IS: The cool thing is that this doesn't just work for SO(3) only. The authors give a few examples of where we can translate a constrained optimisation problem into an unconstrained one in SO(3). For example, it is also possible to optimise functions defined on the unit sphere this way! The reason all this works is due to some results in matrix Lie group theory, an introduction to which can be found in the book "Lie Groups, Lie algebras and representations" by Brian C. Hall. It is highly recommended. Cheers,  Willem H. de Boer Homepage: http://www.whdeboer.com=20 