matplotlib-users Mailing List for matplotlib

On Mon, Jun 25, 2012 at 10:03 AM, julien tayon <ju...@ta...> wrote:

> Hello,
>
> I made a crude sonogram https://gist.github.com/2983547 with the note
> names instead of the frequency. But, It really angers me not to be
> able to have a log scale for the frequency.
>
> Does any well known workaround exists?
> Is there an easy way to grosso modo do :
> x = time, y = frequency, z=amplitude of spectre with something like a
> specter of one croche at time = t according to the bpm and make an y
> scale logarithmic, then project the amplitude (z) with a colormap on
> x,y plane according to the amplitude, and and have 3D representation?
>
> Basically, I guess it boils down to know if combining those 2 is
> possible :
> http://matplotlib.sourceforge.net/examples/mplot3d/contourf3d_demo2.html
> + log scale for y. I guess I could improve the result by using
> logscale on Z and colormap
> (
> http://stackoverflow.com/questions/5748076/python-matplotlib-contour-plot-logarithmic-color-scale
> )
>
>
> Since it is only for fun, and I don't want to invest myself too much
> my question is really did I missed something while googling for an
> easy solution and if so, what are the good keywords?
>
> Cheers
> --
> Julien
>
>
Julien,

I am not entirely sure if I understood your question right, but I think I
can answer part of it.  With respect to using a log scale for 3d axes, it
*should* work, but unfortunately, I have never been able to get it to work
properly.  It is an outstanding bug for mplot3d.  The "work-around" is to
do the log transformation yourself for the input x/y/z data.

However, there is no reason why you can't use a LogNorm for your colormap.
Just so you understand, color scales in matplotlib are done in two parts.
We have the "Norm" objects which takes data and produce values between 0
and 1 (and handles bad, over, and under values accordingly).  And we have
"colormap" objects that take values from 0 to 1 and produce an RGB(A)
array.  By default, most functions in matplotlib will use the min/max of
the input data to automatically create a linear Norm object, and will use
the "prism" colormap.  However, you can create a LogNorm object and pass it
in as the 'norm' kwarg in most plotting functions.

I hope this helps!
Ben Root

efiring wrote:
> 
> Not so--the non-interactive backends like svg and pdf do not do anything 
> upon show(), so it sounds like nothing needs to be added to your pgf 
> backend on this score.
> 

Hmm right, when explicitly changing to non gui backends like "ps" or "pdf"
the show command is ignored too. I somehow thought that there must be an
implementation somewhere because I'll get a preview of a latex rendered
figure when using the text.usetex option.. but this option seems to trigger
a completely different rendering path anyways.

The funny thing is that when enabling text.usetex, which I'm not using in my
backend in any way, my PDF ends up with additional text elements I did not
create. I have no idea how matplotlib manages to tap into my PDF creation
process :D.

Anyway.. one less problem to worry about then :)
Thanks
-- 
View this message in context: http://old.nabble.com/Pgf-Backend-with-Xelatex-support-tp34072290p34074505.html
Sent from the matplotlib - users mailing list archive at Nabble.com.

On 06/26/2012 03:14 AM, Peter Würtz wrote:
> * Backends like svg or pdf are able to display the document upon show(). I
> don't know how this is achieved without creating a graphical user interface
> myself. The other backends don't implement it.

Not so--the non-interactive backends like svg and pdf do not do anything 
upon show(), so it sounds like nothing needs to be added to your pgf 
backend on this score.

Eric

Hi,

When creating figures to be included in Latex documents I encountered a few
problems. In the end the text rendering just doesn't blend in well, one way
or another. I found that the problems can be fixed by using Xelatex, which
provides full unicode support and is able to use the installed fonts of your
operating system.

I wrote a new backend that uses the "pgf" latex package for drawing
matplotlib figures. It is compatible with pdflatex, xelatex and lualatex.
The pgf pictures can be included in latex documents or can be directly
compiled to PDF by the backend, utilizing the benefits of Xelatex.

The code for the backend and a script creating a test figure is on github:
https://github.com/pwuertz/matplotlib-backend-pgf/

A document that demonstrates the benefits of using pgf/xelatex is also
there:
https://github.com/pwuertz/matplotlib-backend-pgf/raw/master/demo/demo.pdf

Although I think the pgf backend is very useful already and produces figures
in publication quality (an overused expression ;) ), there are still some
loose ends. Basically, everything I need works but I don't have the time
anymore to figure out all the rest. Maybe someone is interested in improving
this backend, possibly making it a real option for the masses? I wrote down
all open questions I had in TODO comments within the code. To summarize
them:

* The default font for the backend is the unicode variant of Computer Modern
(CMU Serif), which might not be present on most users' systems. If you don't
want to install/use it, you can just specify another (see test script). I
could as well check for the fonts specified in the rc parameters but these
just do fit in Latex documents.

* When printing pgf commands, the actual font depends on the latex
environment you are embedding the figure in. Matplotlib only needs a font
for calculating the text positions and for direct PDF output.

* I'm not sure how certain draw methods of the renderer should behave due to
lack of documentation.

* Some text properties like switching font families or making the text
italic/bold are ignored since I did not need them.

* Backends like svg or pdf are able to display the document upon show(). I
don't know how this is achieved without creating a graphical user interface
myself. The other backends don't implement it.

* The method of obtaining the metrics of text elements is pretty cool I
think (XelatexManager), but it breaks easily since there is no way of
defining a timeout for reading the output of a subprocesses that keeps
running during the figure creation process. Right now, if Latex doesn't
understand a text-element the process stalls. An alternative is to run a new
latex process for every single text element or start using threads.

-- 
View this message in context: http://old.nabble.com/Pgf-Backend-with-Xelatex-support-tp34072290p34072290.html
Sent from the matplotlib - users mailing list archive at Nabble.com.