matplotlib-users Mailing List for matplotlib

On Wed, Dec 12, 2012 at 7:55 AM, Forrester, Kurt <
kur...@gm...> wrote:

> ax.set_xlim(0.5, 2)
> ax.set_xscale('log', basex=2, subsx=range(2,9))
>


Kurt,

That `subsx` kwarg is tricky. Does this example get you closer to what you
want?

import numpy as np
import matplotlib.pyplot as plt
fig, ax = plt.subplots()
ax.set_xlim(0.5, 10)
ax.set_xscale('log', basex=2, subsx=np.arange(1.,2.1,0.1))
ax.xaxis.grid(True, which='minor')
plt.show()

-paul

I cannot seem to get the following code produce what I expect. I want minor
tick marks between my major ticks on a base 2 logx plot.

ax = axes()
ax.set_xlim(0.5, 2)
ax.set_xscale('log', basex=2, subsx=range(2,9))
grid(b=True, which='minor')

I would have expected there to be minor ticks at 2^(-1:0.1:1) excluding
-1,0 and 1. Any help would be appreciated.

Kind regards,

Kurt

Hi everyone,

Just FYI, IPython just received $1.15 million in funding from the Alfred 
P. Sloan Foundation to support development over the next 2 years. 
Fernando talks more about this in his post to the IPython mailing list:

http://mail.scipy.org/pipermail/ipython-dev/2012-December/010799.html

It's great to see a significant open-source python project that many of 
us use on a day-to-day basis get such great funding!

Thanks,

Jason

--
Jason Grout

Greetings,

With the help of sankey-toolbox, we can plot sankey-diagrams automaticly:
The position of a sankey-object is automaticly calculated based on the
position of its prior-object and cannot be given manually; and when a
sankey-diagram is initialized, the position of the first sankey-object will
be assigned with the input of an axis. (the (0,0)-point will be the
center-point of this object)

And Here is the situation: i want to draw two sankey-diagrams in the same
subplot with a given y-offset, therefore are two coordinate systems with
y-offset required. I have tried the 'add_axes' method, but with this method
a new subplot is created and there will be a graphic scaling problem.

Now this is the question: Is it possible to create a new coordinate system
with a given y-offset, without creating new subplot?



--
View this message in context: http://matplotlib.1069221.n5.nabble.com/create-an-new-axis-with-y-offset-in-the-same-subplot-tp40006.html
Sent from the matplotlib - users mailing list archive at Nabble.com.

On 2012/12/11 1:24 PM, Timothy Duly wrote:
> Thanks Eric, this did the trick.  I did not know such a thing existed.
>   Why "4"?

I don't remember exactly what the defaults are for different types of 
artist, and didn't want to take the time to look, but I think they are 
all less than 4.  So I just picked that as a value that would do the job.

Eric

>
> Tim
>
>
> On Tue, Dec 11, 2012 at 4:35 PM, Eric Firing <ef...@ha...
> <mailto:ef...@ha...>> wrote:
>
>     On 2012/12/11 12:16 PM, Timothy Duly wrote:
>      > Hi,
>      >
>      > I'm running into a problem with overlaying a scatter plot on a
>     polygon
>      > that is on a Basemap.  The polygon covers up the scatter plot
>     created by
>      > the basemap.  To show the issue, the simple example below and broken
>      > down into three steps: 1) creating the map, 2) adding the red
>     polygon,
>      > and 3) adding the "x" markers via a scatter plot.  You will see
>     that the
>      > "x" markers are not on top of the polygon.
>      >
>      > Why does the polygon cover up the markers, even though I have the
>      > markers added after the polygon?  Would there be a better way to do
>      > this?  I could set the polygon alpha to, say, 0.5, but this
>     feature does
>      > not show when I save it as an eps image.  Therefore, I would like to
>      > keep alpha=1.
>
>     Artists have a zorder attribute that controls the drawing order.  Try
>     adding the kwarg zorder=4 to your scatter call.  I think that will take
>     care of it.  (Alternatively you could lower the zorder of the polygon.)
>
>     Eric
>
>      >
>      > Thanks,
>      > Tim
>      >
>      > from mpl_toolkits.basemap import Basemap
>      > import numpy as np
>      > from matplotlib.pyplot import *
>      > from matplotlib.patches import Polygon
>      >
>      >
>      > # ---------------------
>      > # Part 1: Draw the map
>      > # ---------------------
>      >
>      > # Hawaii:
>      > lat_0 = 20.71-8.
>      > lon_0 = 203.83
>      >
>      > figure(1); clf();
>      > m = Basemap(width=2500e3,height=2500e3,
>      >          resolution='l',projection='stere', \
>      >                  lat_ts=lat_0,lat_0=lat_0,lon_0=lon_0)
>      >
>      > m.drawcoastlines()
>      > m.fillcontinents(color='coral',lake_color='aqua')
>      >
>      > # draw parallels and meridians:
>      > m.drawmapboundary(fill_color='aqua')
>      >
>      > lats = np.arange(np.floor(m.latmin),np.ceil(m.latmax),2.)
>      > lons = np.arange(190.,211.,5.)
>      > m.drawparallels(lats,labels=[True,False,False,False])
>      > m.drawmeridians(lons,labels=[False,False,False,True])
>      >
>      > draw(); show()
>      >
>      > # ---------------------
>      > # Part 2: Add a polygon
>      > # ---------------------
>      >
>      > lon_poly = np.array([-160., -150., -150., -160.,])
>      > lat_poly = np.array([10., 10., 14., 14.,])
>      > X, Y  = m(lon_poly, lat_poly)
>      > xy = np.vstack([X,Y]).T
>      >
>      > poly = Polygon(xy, closed=True, \
>      >          facecolor='red', \
>      >          linewidth=1., \
>      >          )
>      >
>      > gca().add_patch(poly)
>      >
>      > # ---------------------
>      > # Part 3: add some 'x' markers
>      > # ---------------------
>      >
>      > lon_markers = np.arange(-168.,-144.,2.)
>      > lat_markers = np.arange(5.,20.,1.)
>      > X, Y = np.meshgrid(lon_markers, lat_markers)
>      >
>      > x, y = m(X.ravel(), Y.ravel())
>      > m.scatter(x,y,marker='x')
>      >
>      > draw(); show()
>      >
>      >
>      >
>      >
>     ------------------------------------------------------------------------------
>      > LogMeIn Rescue: Anywhere, Anytime Remote support for IT. Free Trial
>      > Remotely access PCs and mobile devices and provide instant support
>      > Improve your efficiency, and focus on delivering more value-add
>     services
>      > Discover what IT Professionals Know. Rescue delivers
>      > http://p.sf.net/sfu/logmein_12329d2d
>      >
>      >
>      >
>      > _______________________________________________
>      > Matplotlib-users mailing list
>      > Mat...@li...
>     <mailto:Mat...@li...>
>      > https://lists.sourceforge.net/lists/listinfo/matplotlib-users
>      >
>
>
>     ------------------------------------------------------------------------------
>     LogMeIn Rescue: Anywhere, Anytime Remote support for IT. Free Trial
>     Remotely access PCs and mobile devices and provide instant support
>     Improve your efficiency, and focus on delivering more value-add services
>     Discover what IT Professionals Know. Rescue delivers
>     http://p.sf.net/sfu/logmein_12329d2d
>     _______________________________________________
>     Matplotlib-users mailing list
>     Mat...@li...
>     <mailto:Mat...@li...>
>     https://lists.sourceforge.net/lists/listinfo/matplotlib-users
>
>

On Tue, Dec 11, 2012 at 1:16 PM, Benjamin Root <ben...@ou...> wrote:
>
>
> On Tue, Dec 11, 2012 at 2:08 PM, Chloe Lewis <ch...@be...> wrote:
>>
>> Would it be workable for the default to be proportional to the size of the
>> array passed in? (suggested only because I do that myself, when deciding how
>> coarse an investigative plot I can get away with.)
>>
>> &C
>>
>
> That is pretty much what the PR I was referring to does:
>
> https://github.com/matplotlib/matplotlib/pull/1040
>
> It makes it so that the behavior of both plot_surface and plot_wireframe is
> the same in this respect.  So, by default, the rstride and cstride would be
> 1% of the size of your data array.  This would make the default for the
> recent example be 1, therefore showing every point.  I wonder if a
> logarithmic default would make sense to better handle large data arrays?
>
> Thoughts?
> Ben Root

I hope nobody minds if I chime in here.

I'm in favour of making the defaults a little more intelligent that
what is implemented at present, i.e, a constant stride for any
surface. Any non-trivial scaling law to determine what stride to use
will result in more expected behaviour than what our users are
currently seeing.

Could we do better? Could we have plot_surface try and estimate the
stride based on the 'roughness' of the surface to be plotted? This
method would grind to a halt for very rough surfaces, so we could
default to a scaling law in these cases.

What does everyone think about this approach?

-- 
Damon McDougall
http://www.damon-is-a-geek.com
Institute for Computational Engineering Sciences
201 E. 24th St.
Stop C0200
The University of Texas at Austin
Austin, TX 78712-1229