> I also agree with Reinier.  I want my 3d plots to look as close as possible 
> to my 2d plots.  Because mplot3d uses so much of the same matplotlib core, 
> this is trivial.  As Friedrich mentioned, the mplot3d code is actually pretty 
> small.  To me, that is a great feature.   I found the mplot3d code very 
> accessible.

Yes, I agree that it's really readable.  But I didn't understand the
sorting algorithm in plot_surface().

> I do agree that there is still much work to be done in mplot3d.  But I think 
> starting from scratch is a waste of time.

Well, I see ... When I write code "from scratch" as I often do, I mean
to open a new file and to copy old code only if it useful or
necessary.  So I don't want to break the old code.  I in fact think
the current code is doing good work.  But to my perception, it
nevetheless needs some additional concepts like the global "surface
space" and another sorting algorithm.

> FYI, I looked into using mayavi2 before settling on mplot3d.  Mayavi can 
> create some stunning graphics, but I found that it is very restrictive in its 
> plotting options.  Take for example the 3d scatter plot.  They combined the 
> size and color parameter.  Getting around this strange restriction took me 
> quite some time.  (Installation for me was also a pain due to VTK).

That's important information, at least for me.  I was so impressed by
mayavi, that I was near to be stopped from all enthusiasm for mplot3d.
 But I see, there would be some use.  The arguments you gave are
already quite strong.  I think the possibility to plot 2d things in 3d
context like a stack of curves using the matplotlib style seems to be
quite a good thing, isn't it?

I would like to tell some "fresh look" onto the problem just coming
into my mind.  What about turning matplotlib itself into the 3D
rendering engine?  This would maybe be like a fork.  But it would
leave all matplotlib commands intact, putting the layer like this:

matplotlib
------------------
3D rendering engine
------------------
backend

Instead of:

3D rendering engine
--------------------
matplotlib
--------------------
backend.

I mean, the matplotlib would create some kind of plotting commands,
either 2d or 3d.  The 3d ones would be translated into 2d camera space
by the intersecting layer.  2d ones would be promoted to the 3d camera
space before being projected into the 2d camera space.  This is a raw
idea, I'm shure, so please don't kill me for it.  When it turns out to
be without substance, I would not be offended.

How feasible would this be?

Friedrich

P.S.: But it would maybe simplify the sorting much.  The 3D engine
stores the projected polygons with z information (z as the depth from
the camera).  When another polygon arrives, it will be cut /after
projection/ into pieces based on the polygons in front of it, and be
drawn upon all polygons behind.  The weel again?

P.P.S.: I'm very un-self-confident about this ideas.  But I read, in
OSS one should also publish half-baken ideas, even when they do not
compile ...

------------------------------------------------------------------------------
Download Intel® Parallel Studio Eval
Try the new software tools for yourself. Speed compiling, find bugs
proactively, and fine-tune applications for parallel performance.
See why Intel Parallel Studio got high marks during beta.
http://p.sf.net/sfu/intel-sw-dev
_______________________________________________
Matplotlib-users mailing list
Matplotlib-users@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/matplotlib-users

Reply via email to