Hello!
Im a 3rd year undergraduate student of Computer Science and Id love to work with Octave for GSoC 2013.
I took a look at the Project Ideas page and really liked the projects under Graphics (The OpenGL Selection and the non-OpenGL implementation).
Im downloading the development version of Octave from the repos right now and should have it ready in a day.
Iv done some work with 2D graphics libraries like PyGame and some OpenGL too.
Could you please give me some pointers as to how I should proceed ?
Concerning the OpenGL selection mechanism, I just realize now that it was left in the project ideas. This is something that I handled in QtHandles, at least partially. See [1] and [2]. There's probably some improvement to be done, but it's already a good starting point.
Concerning the non-OpenGL renderer, the idea would be to re-engineer the opengl_renderer class and factor the common parts into a base class that is inherited by the actual renderers. Currently, there's loads of code in opengl_renderer that is related to axis transformation and is independent of the renderer. Once the code is reorganized, you can define a new renderer using another engine, like Cairo or Qt. The idea here would be to focus on 2D rendering, to produce high-quality graphics, where OpenGL is not really suited (like rendering overlapping surfaces lying at the same Z coordinate, from the camera point of view)
If you have some OpenGL knowledge, I can think of 2 possible improvement to the OpenGL renderer:
- double-precision rendering: the current renderer delegates (almost) the entire transformation to OpenGL, but as OpenGL is using floating precision, it leads to incorrect plots when double precision is required (see for instance [3]); I would be in favor of addressing the issue in the renderer, by offsetting and scaling data in C++ before sending them to OpenGL
- transparency handling: the current OpenGL renderer does not support transparency; this is something I didn't port from JHandles, because I didn't really like the solution I used; the problem here is that, AFAIK, if you really want to have correct handling of transparency, you need to depth-sort the primitives before rendering them; there might be other solutions, I'm not really an OpenGL expert
Michael.