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

_{Feb}

_{Mar}

_{Apr}

_{May}

_{Jun}

_{Jul}

_{Aug}

_{Sep}
(81) 
_{Oct}
(41) 
_{Nov}
(55) 
_{Dec}
(14) 

2002 
_{Jan}
(34) 
_{Feb}
(3) 
_{Mar}
(16) 
_{Apr}
(5) 
_{May}
(10) 
_{Jun}
(13) 
_{Jul}
(24) 
_{Aug}
(14) 
_{Sep}
(14) 
_{Oct}
(9) 
_{Nov}
(10) 
_{Dec}
(16) 
2003 
_{Jan}
(25) 
_{Feb}
(59) 
_{Mar}
(9) 
_{Apr}
(21) 
_{May}
(54) 
_{Jun}
(4) 
_{Jul}
(16) 
_{Aug}
(19) 
_{Sep}
(19) 
_{Oct}
(15) 
_{Nov}
(13) 
_{Dec}
(22) 
2004 
_{Jan}
(19) 
_{Feb}
(8) 
_{Mar}
(20) 
_{Apr}
(16) 
_{May}
(13) 
_{Jun}
(18) 
_{Jul}
(18) 
_{Aug}
(14) 
_{Sep}
(24) 
_{Oct}
(47) 
_{Nov}
(20) 
_{Dec}
(10) 
2005 
_{Jan}
(23) 
_{Feb}
(31) 
_{Mar}
(11) 
_{Apr}
(29) 
_{May}
(18) 
_{Jun}
(7) 
_{Jul}
(11) 
_{Aug}
(12) 
_{Sep}
(8) 
_{Oct}
(4) 
_{Nov}
(11) 
_{Dec}
(7) 
2006 
_{Jan}
(7) 
_{Feb}
(8) 
_{Mar}
(15) 
_{Apr}
(3) 
_{May}
(8) 
_{Jun}
(25) 
_{Jul}
(19) 
_{Aug}
(3) 
_{Sep}
(17) 
_{Oct}
(27) 
_{Nov}
(24) 
_{Dec}
(9) 
2007 
_{Jan}
(6) 
_{Feb}
(43) 
_{Mar}
(33) 
_{Apr}
(8) 
_{May}
(20) 
_{Jun}
(11) 
_{Jul}
(7) 
_{Aug}
(8) 
_{Sep}
(11) 
_{Oct}
(22) 
_{Nov}
(15) 
_{Dec}
(18) 
2008 
_{Jan}
(14) 
_{Feb}
(6) 
_{Mar}
(6) 
_{Apr}
(37) 
_{May}
(13) 
_{Jun}
(17) 
_{Jul}
(22) 
_{Aug}
(16) 
_{Sep}
(14) 
_{Oct}
(16) 
_{Nov}
(29) 
_{Dec}
(13) 
2009 
_{Jan}
(7) 
_{Feb}
(25) 
_{Mar}
(38) 
_{Apr}
(57) 
_{May}
(12) 
_{Jun}
(32) 
_{Jul}
(32) 
_{Aug}
(35) 
_{Sep}
(10) 
_{Oct}
(28) 
_{Nov}
(16) 
_{Dec}
(49) 
2010 
_{Jan}
(57) 
_{Feb}
(37) 
_{Mar}
(22) 
_{Apr}
(15) 
_{May}
(45) 
_{Jun}
(25) 
_{Jul}
(32) 
_{Aug}
(7) 
_{Sep}
(13) 
_{Oct}
(2) 
_{Nov}
(11) 
_{Dec}
(28) 
2011 
_{Jan}
(35) 
_{Feb}
(39) 
_{Mar}

_{Apr}
(25) 
_{May}
(32) 
_{Jun}
(17) 
_{Jul}
(29) 
_{Aug}
(10) 
_{Sep}
(26) 
_{Oct}
(9) 
_{Nov}
(28) 
_{Dec}
(4) 
2012 
_{Jan}
(24) 
_{Feb}
(47) 
_{Mar}
(4) 
_{Apr}
(8) 
_{May}
(9) 
_{Jun}
(6) 
_{Jul}
(4) 
_{Aug}
(1) 
_{Sep}
(4) 
_{Oct}
(28) 
_{Nov}
(2) 
_{Dec}
(2) 
2013 
_{Jan}
(11) 
_{Feb}
(3) 
_{Mar}
(4) 
_{Apr}
(38) 
_{May}
(15) 
_{Jun}
(11) 
_{Jul}
(15) 
_{Aug}
(2) 
_{Sep}
(2) 
_{Oct}
(4) 
_{Nov}
(3) 
_{Dec}
(14) 
2014 
_{Jan}
(24) 
_{Feb}
(31) 
_{Mar}
(28) 
_{Apr}
(16) 
_{May}
(7) 
_{Jun}
(6) 
_{Jul}
(1) 
_{Aug}
(10) 
_{Sep}
(10) 
_{Oct}
(2) 
_{Nov}

_{Dec}

2015 
_{Jan}
(6) 
_{Feb}
(5) 
_{Mar}
(2) 
_{Apr}
(1) 
_{May}

_{Jun}

_{Jul}
(1) 
_{Aug}
(1) 
_{Sep}
(2) 
_{Oct}
(1) 
_{Nov}
(19) 
_{Dec}

2016 
_{Jan}
(6) 
_{Feb}
(1) 
_{Mar}
(7) 
_{Apr}

_{May}
(6) 
_{Jun}

_{Jul}
(3) 
_{Aug}
(7) 
_{Sep}

_{Oct}
(2) 
_{Nov}
(2) 
_{Dec}

2017 
_{Jan}

_{Feb}
(6) 
_{Mar}
(8) 
_{Apr}

_{May}

_{Jun}

_{Jul}

_{Aug}

_{Sep}

_{Oct}

_{Nov}

_{Dec}

S  M  T  W  T  F  S 


1
(2) 
2

3

4

5

6

7

8
(2) 
9
(5) 
10

11
(2) 
12
(1) 
13

14

15

16

17
(3) 
18

19

20

21
(1) 
22
(1) 
23

24

25
(1) 
26
(4) 
27

28

29

30

31




From: Greg Ewing <greg.ewing@ca...>  20100309 23:36:58

Kolja Kaehler wrote: >  Rowmajor vs. columnmajor matrices. With the default > rowmajor layout used by numpy, I always have to pass in matrices as the > transpose of what I expect. I found out I can create numpy arrays with > ‘F’ order, but I still have to transpose matrices I get back from > PyOpenGL, it seems. You might like to consider just working with the transposed arrays as they are. Thinking about this recently, I realised that the OpenGL order may actually be more convenient for some things, such as transforming an array of vertices. With a transposed matrix, you can do A*M, where A is an nby4 array. With a nontransposed matrix, you would have to do M*A and transpose A into a 4byn array. >  What’s a good way to build a dynamically growing vertex > array? ... Currently, I am setting up an array with > shape(n,3) and concatenate another array of length 3 to it. ... I > believe it’s always making a copy. Yes, that will be horribly inefficient. I would build up a list of vertices first, and then convert the whole list to an array in one go. > To transform a 3D vector with a 4x4 matrix, I have to append an > extra 1.0 element, do the multiplication, and then slice off the 4^th > element again. Another way is to work with 4element vectors throughout.  Greg 
From: Ian Mallett <geometrian@gm...>  20100309 20:45:59

On Tue, Mar 9, 2010 at 2:58 AM, Kolja Kaehler <kolja.kaehler@...>wrote: >  My hope was to avoid having to do my own 3Dvector and > matrixclasses for doing linear algebra, and just use numpy’s abilities. It > turns out that this is not always so effortless – e.g. to multiply a matrix > with a vector from the right, I have to make sure it’s a column vector. To > transform a 3D vector with a 4x4 matrix, I have to append an extra 1.0 > element, do the multiplication, and then slice off the 4th element again. > Looks like it would be cleaner to write out the whole matrix/vector > multiplication by hand. > Scale and rotate matrices need only be 3x3 matrices. Translation matrices, which must be 4x4, can instead be expressed as simple addition: e.g., vertex_array += array([1,2,6]) You might also want to consider keeping your vertices as vec4sthat's how OpenGL stores vertices interally, even if you only define the x and y, or the x,y, and z coordinates. You may also consider using OpenGL's own matrix system. It's technically deprecatedbut it's still an awes Ian 
From: Dan Helfman <Dan.Helfman@no...>  20100309 18:14:08

Kolja Kaehler wrote: > Does anyone here have some advice for me on these matters? Maybe I am > just missing “the obvious way” to organize these things. Hi Kolja, I haven't had any problems using NumPy's rowmajor arrays with PyOpenGL. For instance if you have a rowmajor NumPy array of dtype [ ( "x", np.float32 ), ( "y", np.float32 ) ], you can pass the array directly to PyOpenGL by putting it in a vertex buffer object and then using glVertexPointer( 2, gl.GL_FLOAT, 0, None ) to tell GL to expect 2 floats for each vertex. The same principle works for 3D as well. And if you'd like to store several pieces of NumPy array data together, then you can just use a recarray, and then pass an individual "member" array to PyOpenGL at any point you want. Perhaps you can give an example of what you're trying to do where the rowmajor/columnmajor distinction gets in the way? There really isn't a good way to dynamically grow a vertex array with NumPy. Some options are: * Use numpy.resize(), which just returns a new, larger array copy. * Use numpy.ndarray.resize(), which can only resize if there are no other references to the array. * Accumulate and grow with a data structure other than a NumPy array, and then convert to a NumPy array when you're done growing. Some candidates are a Python list (slow), or if you're willing to use Cython or C, then accumulate in a C array with realloc() for growing. I haven't really used NumPy matrices, so I'll let someone else comment on that one. Dan 
From: Cata <catalinfest@gm...>  20100309 11:59:30

It is ok now . I see where is the error ... See my result : http://img121.imageshack.us/img121/9318/gluttest.png  My sites: http://catalinfestila.blogspot.com about me http://tv.freetutorials.org  video tutorials http://pythoncatalin.blogspot.com  my python blog 
From: Kolja Kaehler <kolja.kaehler@av...>  20100309 11:10:35

Hi all, I've recently discovered PyOpenGL and am quite happy with this package (kudos to the authors!). It's just great for prototyping on different platforms. I keep struggling with how I should best represent vertex data and matrices, though. Here are some of my favorite problems:  Rowmajor vs. columnmajor matrices. With the default rowmajor layout used by numpy, I always have to pass in matrices as the transpose of what I expect. I found out I can create numpy arrays with 'F' order, but I still have to transpose matrices I get back from PyOpenGL, it seems.  What's a good way to build a dynamically growing vertex array? Sort of the equivalent of a std::vector<Vec3f> in C++, with struct Vec3f { float p[3]; }. Currently, I am setting up an array with shape(n,3) and concatenate another array of length 3 to it. It looks horrible in code (sorry, I can't remember the syntax right now), and I believe it's always making a copy.  My hope was to avoid having to do my own 3Dvector and matrixclasses for doing linear algebra, and just use numpy's abilities. It turns out that this is not always so effortless  e.g. to multiply a matrix with a vector from the right, I have to make sure it's a column vector. To transform a 3D vector with a 4x4 matrix, I have to append an extra 1.0 element, do the multiplication, and then slice off the 4th element again. Looks like it would be cleaner to write out the whole matrix/vector multiplication by hand. Does anyone here have some advice for me on these matters? Maybe I am just missing "the obvious way" to organize these things. Thanks, Kolja 