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
(17) 
2
(3) 
3
(4) 
4
(14) 
5
(12) 
6
(16) 
7
(28) 
8
(28) 
9
(12) 
10
(5) 
11
(17) 
12
(16) 
13
(37) 
14
(26) 
15
(10) 
16
(1) 
17
(2) 
18
(11) 
19
(9) 
20
(22) 
21
(14) 
22
(23) 
23
(4) 
24
(2) 
25
(16) 
26
(6) 
27
(3) 
28
(5) 
29
(4) 
30
(2) 
From: Casey Muratori <gda@fu...>  20021126 22:00:41

> A unit quaternion is no more and no less than than a rotation around an > axis  handedness (relative to the coordinate frame) is explicit, > because the signs of each of the sine and cosine components are included > in the quaternion. OK I think this thread is starting to get out of control, so here we go: Quaternions have no handedness. I'm not sure how the initial concept that a quaternion has a handedness got started, but to quote Marsellus Wallace, "it don't". Just like vectors, there is only a handedness to your _operations_. You wouldn't call your vectors lefthanded or righthanded, would you? But you _would_ (or I certainly hope you would!) call your crossproduct lefthanded or righthanded, correct? The same situation applies to quaternions. When you wrote your quaternion multiply, you used a cross product (or, as is apparently more likely, if you cut and pasted somebody else's code, THEY used a cross product). If your/their cross product is righthanded, then your/their quaternions are going to multiply righthanded. If it's left, they'll multiply left. It's really that simple. Or, if you prefer, "it's really that complicated". And so forth. Now as for this this: > I'd love to see Ron's (or some other mathematician's) explanation of how > handedness is incorporated into this representation. I have my own > explanation, but I'm not a mathematician myself! Thankfully, the explanation is simple and doesn't require a mathematician. As everyone has seen many times, quaternion operations are all defined by setting up multiplication rules for the imaginary components i, j, and k. Well, if you had been ignoring those derivations previously, now's your chance to stop ignoring them. Go back and look, and you'll see that the "handedness" is baked into those initial definitions. If you change the initial multiplication rules to be lefthanded, then all the operations will come out lefthanded. Right handed systems have: i^2 = j^2 = k^2 = ijk = 1 i = jk = kj j = ki = ik k = ij = ji and left handed systems have: i^2 = j^2 = k^2 = ijk = 1 i = jk = kj j = ki = ik k = ij = ji And that's all there is to it. k is the "zaxis". If you want to invert your z axis, you just define the fact that i (xaxis) and j (yaxis) multiply together to get negative k. Obviously, you don't have to restrict yourself to making k negative, you could've negated something else instead. For some reason, Shoemake never presented the lefthanded version (as far as I'm aware), so I guess nobody ever thought about it? Not sure. Anyhow, go ahead and do the quaternion multiplication (w + xi + yj + zk) (d + ai + bj + ck) with each rule set and see what you get. You'll find that you get a righthanded cross product when you use the righthanded rules, and a left handed cross product when you use the lefthanded rules, and otherwise the two will be identical. <rant> Now I would simply like to say hey, if I had to hazard a guess as to why everyone thinks quaternions are inherently righthanded, and the lefthanded definition doesn't ever show up, I'd say it's because that's the way most math is written by default: righthanded. So when you go and read something in a math book, it's probably righthanded. So why do some people still insist on using these lefthanded coordinate frames? For the love of god, people, stop using lefthanded coordinate systems so we can put an end to all this useless conversion confusion. There's no advantage to one or the other  they're the same in every way. So why can't we just adopt math's convention of using predominantly righthanded operations and live saner lives where we never have to have a thread like this again? </rant>  Casey 
From: Tyson Jensen <twjensen@sa...>  20021126 17:44:19

Actually, technically a quaternion multiply (unit or otherwise) represents a screw transform. The typical way quaternions are applied, ie qvq* where q is a unit quaternion, insures that the translational element is removed leaving a pure rotation. Since we game programmers haven't really gotten into screw theory, all of our quaternions represent rotations. As with many mathematical constructions, our plans for how we are going to use them make a big difference in what they represent. For example, a matrix can do all kinds of things besides rotate and translate but the only thing we typically do outside of those is a perspective transform. Original Message From: gdalgorithmslistadmin@... [mailto:gdalgorithmslistadmin@...] On Behalf Of Nick Pelling Sent: Tuesday, November 26, 2002 2:52 AM To: 'gdalgorithmslist@...' Subject: RE: [Algorithms] Quaternion handedness A unit quaternion is no more and no less than than a rotation around an axis  handedness (relative to the coordinate frame) is explicit, because the signs of each of the sine and cosine components are included in the quaternion. Also: in normal rotation matrices, the resulting matrix is composited out of a sequences of rotation matrices, and is both ordersensitive and handednesssensitive. However, for a rotation angle 3tuple, the handedness is implicit, as are its axis association and order. So: when linking between rotation angle 3tuples and quaternions, you need to get all the implicit stuff right, or you'll get a load of nonsense. Unsurprisingly, "This Often Happens". :/ I could put a load of quaternion maths in here to demonstrate this basic point, but it really shouldn't be necessary. :) Cheers, .....Nick Pelling..... Original Message From: Peter Lipson [mailto:peter@...] Sent: 25 November 2002 18:16 To: gdalgorithmslist@... Subject: RE: [Algorithms] Quaternion handedness This whole discussion seems to be lacking any answer based on the theoretical basis for using quaternions to hold the rotations. I know quaternions used for rotation are constructed by using the axis and sin/cos of the angle, but I have a less firm grasp of the theoretical underpinnings that guarantee this 'works'. I'd love to see Ron's (or some other mathematician's) explanation of how handedness is incorporated into this representation. I have my own explanation, but I'm not a mathematician myself!  This SF.net email is sponsored by: Get the new Palm Tungsten T handheld. Power & Color in a compact size! http://ads.sourceforge.net/cgibin/redirect.pl?palm0002en _______________________________________________ GDAlgorithmslist mailing list GDAlgorithmslist@... https://lists.sourceforge.net/lists/listinfo/gdalgorithmslist Archives: http://sourceforge.net/mailarchive/forum.php?forum_id=6188 
From: Guillaume Provost <Guillaume@ps...>  20021126 14:37:48

Ron, This is actually all the help I needed. I'm familiar with Jacobian matrices and I think I can take it from here. Thanks alot! Guillaume. Original Message From: gdalgorithmslistadmin@... [mailto:gdalgorithmslistadmin@...]On Behalf Of Ron Levine Sent: Tuesday, November 26, 2002 3:42 AM To: gdalgorithmslist@... Subject: Re: [Algorithms] Normal space transforms for nonlinear deformatio ns Guillaume Provost wrote: > > Thought I would have a neat problem for you math freaks. > We have >been deforming meshes in hardware using single axis aligned quadratic >7point blend >deforms. (You basically take one of the axis and you transform it through a >quadratic). > >I have until now approximated the normal transforms using a standard >rigid body matrix that best averaged this transform, but I'm now facing some >highly >glossy surfaces, and the defects in the shading are showing up. Do any of >you have source >materials/ideas on how I could better approximate the correct normal >transforms in such a case? > >The basic math : > >The Power vector: [x y z 1 xx xy xz] // Quadratic deform along the x axis. > >// where rx ry rz tx is your standard rigid deform (these are vectors) >// and rxx rxy rxz are the quadratic blend factors along the x axis >7 point blend: [rx ry rz tx rxx rxy rxz] > >transformed point = Power vector * (7 Point blend) > >// Currently : >normal = Inverse_Transpose(rx ry rz tx) > > Guillaume. > OK I haven't had the time to figure out your nonlinear mapping specification, except to see that it is an analytic nonlinear, nonaffine (quadratic?) mapping of R^3 to itself. But I will try to steer you in the direction of the theory that will help you, which generally comes under the rubrique "Advanced Calculus" (taught in the second year in US universities). The normal you want to the image (transformed) surface is (or is supposed to represent) the normal to its tangent plane. So you have to figure out what your mapping does to the tangent plane at any point of the source surface (however that may be defined). The tangent plane at any point is spanned by the (vector ) partial derivatives of the vector function of a parametric representation of the surface. So it should not be a surprise that the correct mapping of the tangent plane must involve the the partial derivatives of the mapping you have defined. To make a long story short, the transformation matrix you need is called 'the Jacobian matrix' of your defined nonlinear mapping. IF we symbolise your mapping as vector function written out in components (x',y',z') = (x'(x,y,z), y'(x,y,z), (z'(x,y,z)) where (x,y,z) is a general point of the domain of your mapping and (x',y',z') is its image under the mapping, (showing that each of (x',y',z') is a function of (x, y, z)), THEN the Jacobian of the mapping is the 3x3 matrix of all possible partial derivatives of each of (x',y',z') with respect to each of (x, y, z). That is the neatest way I can think of to define the Jacobian in ASCII, (and my distaste for casting math notation into ASCII is one reason I'm not going into more detail) The Jacobian of a linear mapping is just its matrix, and so is constant. The Jacobian of an affine mapping is just the matrix of its linear part. If one understood exactly the definition of your quadratic mapping, computing its Jacobian is a simple exercise in differential calculus of several variables. It will not be constant, but a function of (x,y,z) Now you cannot just apply the Jacobian to the source normal vector to get the image normal vector, because the Jacobian is not likely to be orthogonal and so it will not necessarily preserve cross products. But it will map tangent plane to tangent plane. So, in principle, for any source normal vector at a particular point, you have to get a couple of independent vectors orthogonal to it, apply the Jacobian to them, take the cross product of the result, and normalize. That's all the time I have, maybe someone else will pick up the ball and fill in holes I'm leaving. At least, I hope that's push in a direction you might find rewarding.  This SF.net email is sponsored by: Get the new Palm Tungsten T handheld. Power & Color in a compact size! http://ads.sourceforge.net/cgibin/redirect.pl?palm0002en _______________________________________________ GDAlgorithmslist mailing list GDAlgorithmslist@... https://lists.sourceforge.net/lists/listinfo/gdalgorithmslist Archives: http://sourceforge.net/mailarchive/forum.php?forum_id=6188 
From: Ron Levine <ron@do...>  20021126 12:41:16

Guillaume Provost wrote: > > Thought I would have a neat problem for you math freaks. > We have >been deforming meshes in hardware using single axis aligned quadratic >7point blend >deforms. (You basically take one of the axis and you transform it through a >quadratic). > >I have until now approximated the normal transforms using a standard >rigid body matrix that best averaged this transform, but I'm now facing some >highly >glossy surfaces, and the defects in the shading are showing up. Do any of >you have source >materials/ideas on how I could better approximate the correct normal >transforms in such a case? > >The basic math : > >The Power vector: [x y z 1 xx xy xz] // Quadratic deform along the x axis. > >// where rx ry rz tx is your standard rigid deform (these are vectors) >// and rxx rxy rxz are the quadratic blend factors along the x axis >7 point blend: [rx ry rz tx rxx rxy rxz] > >transformed point = Power vector * (7 Point blend) > >// Currently : >normal = Inverse_Transpose(rx ry rz tx) > > Guillaume. > OK I haven't had the time to figure out your nonlinear mapping specification, except to see that it is an analytic nonlinear, nonaffine (quadratic?) mapping of R^3 to itself. But I will try to steer you in the direction of the theory that will help you, which generally comes under the rubrique "Advanced Calculus" (taught in the second year in US universities). The normal you want to the image (transformed) surface is (or is supposed to represent) the normal to its tangent plane. So you have to figure out what your mapping does to the tangent plane at any point of the source surface (however that may be defined). The tangent plane at any point is spanned by the (vector ) partial derivatives of the vector function of a parametric representation of the surface. So it should not be a surprise that the correct mapping of the tangent plane must involve the the partial derivatives of the mapping you have defined. To make a long story short, the transformation matrix you need is called 'the Jacobian matrix' of your defined nonlinear mapping. IF we symbolise your mapping as vector function written out in components (x',y',z') = (x'(x,y,z), y'(x,y,z), (z'(x,y,z)) where (x,y,z) is a general point of the domain of your mapping and (x',y',z') is its image under the mapping, (showing that each of (x',y',z') is a function of (x, y, z)), THEN the Jacobian of the mapping is the 3x3 matrix of all possible partial derivatives of each of (x',y',z') with respect to each of (x, y, z). That is the neatest way I can think of to define the Jacobian in ASCII, (and my distaste for casting math notation into ASCII is one reason I'm not going into more detail) The Jacobian of a linear mapping is just its matrix, and so is constant. The Jacobian of an affine mapping is just the matrix of its linear part. If one understood exactly the definition of your quadratic mapping, computing its Jacobian is a simple exercise in differential calculus of several variables. It will not be constant, but a function of (x,y,z) Now you cannot just apply the Jacobian to the source normal vector to get the image normal vector, because the Jacobian is not likely to be orthogonal and so it will not necessarily preserve cross products. But it will map tangent plane to tangent plane. So, in principle, for any source normal vector at a particular point, you have to get a couple of independent vectors orthogonal to it, apply the Jacobian to them, take the cross product of the result, and normalize. That's all the time I have, maybe someone else will pick up the ball and fill in holes I'm leaving. At least, I hope that's push in a direction you might find rewarding. 
From: Atman Binstock <ajb@pa...>  20021126 12:36:22

Adrian Perez wrote: >One of the shrek programmers posted a fantastically awesome fix for this > just use stippled alpha with a checkerboard stipple pattern. >It's only reasonable on televisions (the stipple pattern gets lost in >the noise and you can't see it) Charles Bloom wrote: >though if you have a crappy TV (like many consumers do) the samples will >bleed together pretty well. This is all xbox specific... It's actually the horizontal and (adaptive) vertical filtering performed by the video chip does that blends the samples, and it works pretty well. The only really visible artifacts are a slight loss in apparent resolution (noticeable on edges) and a bit more interlace flickering (as Charles noted). The real problem is on progressive component out (we used 480p)  the video chip does no filtering (which IMO is a mistake) and the stipple patter is clearly visible on a good TV. Atman Binstock ajb@... 
From: Nick Pelling <NPelling@cl...>  20021126 10:51:52

A unit quaternion is no more and no less than than a rotation around an axis  handedness (relative to the coordinate frame) is explicit, because the signs of each of the sine and cosine components are included in the quaternion. Also: in normal rotation matrices, the resulting matrix is composited out of a sequences of rotation matrices, and is both ordersensitive and handednesssensitive. However, for a rotation angle 3tuple, the handedness is implicit, as are its axis association and order. So: when linking between rotation angle 3tuples and quaternions, you need to get all the implicit stuff right, or you'll get a load of nonsense. Unsurprisingly, "This Often Happens". :/ I could put a load of quaternion maths in here to demonstrate this basic point, but it really shouldn't be necessary. :) Cheers, .....Nick Pelling..... Original Message From: Peter Lipson [mailto:peter@...] Sent: 25 November 2002 18:16 To: gdalgorithmslist@... Subject: RE: [Algorithms] Quaternion handedness This whole discussion seems to be lacking any answer based on the theoretical basis for using quaternions to hold the rotations. I know quaternions used for rotation are constructed by using the axis and sin/cos of the angle, but I have a less firm grasp of the theoretical underpinnings that guarantee this 'works'. I'd love to see Ron's (or some other mathematician's) explanation of how handedness is incorporated into this representation. I have my own explanation, but I'm not a mathematician myself! 