matplotlib-users Mailing List for matplotlib

I would like to be able to publish plots that are updated as data are 
received by the server. I don't actually want any of the toolbar 
interactivity--I just want the updated plot to appear in the browser 
automatically. I suspect this can all be done quite easily using the 
webagg backend, but I have not yet figured it out by looking at the 
embedding_in_webagg.py example and the backend_webagg* code. I expect 
that stripping out the toolbar is straightforward, but what I don't 
understand is how to achieve the dynamic updates, preferably without 
using the animation framework, which I think would add unnecessary 
complexity.
Are there any other examples floating around that would help?
Thanks.
Eric

One thing you can do which may work is to partition your plots 'by hand'.
It is not super elegant, but might get you the desired behavior. As long
as the number of partitions is low it shouldn't hurt performance _too_ much.
def z_jitter_plot(ax, x, y, partitions=10, **kwargs):
 labels = np.random.randint(0, partitions, len(y))
 z_levels = 1 + np.random.rand(partitions)
 lns = []
 for n, z in enumerate(z_levels):
 ln = ax.plot(x[labels==n], y[labels==n], zorder=z, **kwargs)
 lns.extend(ln)
 return lns
fig, ax = plt.subplots()
N = 2500
all_lns = []
for j, c in enumerate('rgbk'):
 x = np.linspace(0, 1, N)
 y = np.random.randn(N)
 lns = z_jitter_plot(ax, x, y, partitions=100, color=c, ls='',
markersize=52, marker='o')
 all_lns.extend(lns)
Throwing in `alpha=.5` might also help a bit.
You will have to manage the color cycle your self here as this plots many
lines (each of which wants to advance the color cycle) per data set.
Tom
On Tue, Jun 23, 2015 at 2:16 PM Benjamin Root <ben...@ou...> wrote:
> Right, when zorder is not explicitly specified, all the artists of the
> same type get the same default zorder (I think 2, but I can't remember). We
> then use a stable sort to determine the draw order, so two artists with the
> same zorder are drawn in the order that they were created (the exception
> being mplot3d, because it mucks about with zorders to achieve the 3d
> effect).
>
> Ben Root
>
> On Tue, Jun 23, 2015 at 1:53 PM, Jody Klymak <jk...@uv...> wrote:
>
>>
>> For my backend (nbagg), the order of the data determines the order of
>> drawing. So in the following, the third diamond covers the first two in
>> the first plot, but the first diamond covers them all in the second plot.
>> Perhaps not as elegant as a matrix zorder, but can achieve the effect you
>> are after.
>>
>> Cheers, Jody
>>
>> fig, ax = plt.subplots(2,1)
>> x = np.arange(3)
>> y = 0.*x
>> ax[0].plot(x,y,'d',markersize=52)
>> ax[0].set_xlim(-10.,10.)
>> ax[1].plot(x[[2,1,0]],y[[2,1,0]],'d',markersize=52)
>> ax[1].set_xlim(-10.,10.)
>>
>>
>> On Jun 23, 2015, at 9:44 AM, Benjamin Root <ben...@ou...> wrote:
>>
>> I see what you are getting at. The issue is that artists are first sorted
>> by the zorder and then drawn one at a time. The draw for a collection
>> artist is an at-once operation, it can't (currently) be split out and
>> interspersed with the draws from another artist. This is one of the major
>> limitations for mplot3d, as it would be nice to compose a 3d scene properly
>> so that everything is logically consistent.
>>
>> I have actually been working on some changes that would allow one to sort
>> the draws of individual elements of a collection, but I still haven't
>> figured out a way to "break out" the elements with other collection
>> elements in a way that doesn't break the current design or introduce major
>> performance penalties. Maybe I'll figure something out during SciPy2015.
>>
>> Cheers!
>> Ben Root
>>
>>
>> On Tue, Jun 23, 2015 at 5:44 AM, Simon Walker <
>> s.r...@go...> wrote:
>>
>>> When multiple datasets are plotted on the same axis, the points overlay
>>> each other making it hard to see the points under the most recent ones. One
>>> way to avoid this is to give each point a random zorder, randomising its
>>> position in the z axis. This way, points from the first dataset may overly
>>> points from the last dataset.
>>>
>>> This could be achieved nicely if the zorder keyword took an array so the
>>> random zorder values per point can be pre-computed, but currently it only
>>> accepts a single number for the whole dataset. Would this be a useful
>>> feature for others to have? How difficult would it be to implement?
>>>
>>> Thanks,
>>>
>>> Simon Walker
>>>
>>> ------------------------------------------------------------------------------
>>> Monitor 25 network devices or servers for free with OpManager!
>>> OpManager is web-based network management software that monitors
>>> network devices and physical & virtual servers, alerts via email & sms
>>> for fault. Monitor 25 devices for free with no restriction. Download now
>>> http://ad.doubleclick.net/ddm/clk/292181274;119417398;o
>>> _______________________________________________
>>> Matplotlib-users mailing list
>>> Mat...@li...
>>> https://lists.sourceforge.net/lists/listinfo/matplotlib-users
>>>
>>
>>
>> ------------------------------------------------------------------------------
>> Monitor 25 network devices or servers for free with OpManager!
>> OpManager is web-based network management software that monitors
>> network devices and physical & virtual servers, alerts via email & sms
>> for fault. Monitor 25 devices for free with no restriction. Download now
>>
>> http://ad.doubleclick.net/ddm/clk/292181274;119417398;o_______________________________________________
>> Matplotlib-users mailing list
>> Mat...@li...
>> https://lists.sourceforge.net/lists/listinfo/matplotlib-users
>>
>>
>>
>>
>> ------------------------------------------------------------------------------
>> Monitor 25 network devices or servers for free with OpManager!
>> OpManager is web-based network management software that monitors
>> network devices and physical & virtual servers, alerts via email & sms
>> for fault. Monitor 25 devices for free with no restriction. Download now
>> http://ad.doubleclick.net/ddm/clk/292181274;119417398;o
>> _______________________________________________
>> Matplotlib-users mailing list
>> Mat...@li...
>> https://lists.sourceforge.net/lists/listinfo/matplotlib-users
>>
>>
>
> ------------------------------------------------------------------------------
> Monitor 25 network devices or servers for free with OpManager!
> OpManager is web-based network management software that monitors
> network devices and physical & virtual servers, alerts via email & sms
> for fault. Monitor 25 devices for free with no restriction. Download now
> http://ad.doubleclick.net/ddm/clk/292181274;119417398;o
> _______________________________________________
> Matplotlib-users mailing list
> Mat...@li...
> https://lists.sourceforge.net/lists/listinfo/matplotlib-users
>

Right, when zorder is not explicitly specified, all the artists of the same
type get the same default zorder (I think 2, but I can't remember). We then
use a stable sort to determine the draw order, so two artists with the same
zorder are drawn in the order that they were created (the exception being
mplot3d, because it mucks about with zorders to achieve the 3d effect).
Ben Root
On Tue, Jun 23, 2015 at 1:53 PM, Jody Klymak <jk...@uv...> wrote:
>
> For my backend (nbagg), the order of the data determines the order of
> drawing. So in the following, the third diamond covers the first two in
> the first plot, but the first diamond covers them all in the second plot.
> Perhaps not as elegant as a matrix zorder, but can achieve the effect you
> are after.
>
> Cheers, Jody
>
> fig, ax = plt.subplots(2,1)
> x = np.arange(3)
> y = 0.*x
> ax[0].plot(x,y,'d',markersize=52)
> ax[0].set_xlim(-10.,10.)
> ax[1].plot(x[[2,1,0]],y[[2,1,0]],'d',markersize=52)
> ax[1].set_xlim(-10.,10.)
>
>
> On Jun 23, 2015, at 9:44 AM, Benjamin Root <ben...@ou...> wrote:
>
> I see what you are getting at. The issue is that artists are first sorted
> by the zorder and then drawn one at a time. The draw for a collection
> artist is an at-once operation, it can't (currently) be split out and
> interspersed with the draws from another artist. This is one of the major
> limitations for mplot3d, as it would be nice to compose a 3d scene properly
> so that everything is logically consistent.
>
> I have actually been working on some changes that would allow one to sort
> the draws of individual elements of a collection, but I still haven't
> figured out a way to "break out" the elements with other collection
> elements in a way that doesn't break the current design or introduce major
> performance penalties. Maybe I'll figure something out during SciPy2015.
>
> Cheers!
> Ben Root
>
>
> On Tue, Jun 23, 2015 at 5:44 AM, Simon Walker <
> s.r...@go...> wrote:
>
>> When multiple datasets are plotted on the same axis, the points overlay
>> each other making it hard to see the points under the most recent ones. One
>> way to avoid this is to give each point a random zorder, randomising its
>> position in the z axis. This way, points from the first dataset may overly
>> points from the last dataset.
>>
>> This could be achieved nicely if the zorder keyword took an array so the
>> random zorder values per point can be pre-computed, but currently it only
>> accepts a single number for the whole dataset. Would this be a useful
>> feature for others to have? How difficult would it be to implement?
>>
>> Thanks,
>>
>> Simon Walker
>>
>> ------------------------------------------------------------------------------
>> Monitor 25 network devices or servers for free with OpManager!
>> OpManager is web-based network management software that monitors
>> network devices and physical & virtual servers, alerts via email & sms
>> for fault. Monitor 25 devices for free with no restriction. Download now
>> http://ad.doubleclick.net/ddm/clk/292181274;119417398;o
>> _______________________________________________
>> Matplotlib-users mailing list
>> Mat...@li...
>> https://lists.sourceforge.net/lists/listinfo/matplotlib-users
>>
>
>
> ------------------------------------------------------------------------------
> Monitor 25 network devices or servers for free with OpManager!
> OpManager is web-based network management software that monitors
> network devices and physical & virtual servers, alerts via email & sms
> for fault. Monitor 25 devices for free with no restriction. Download now
>
> http://ad.doubleclick.net/ddm/clk/292181274;119417398;o_______________________________________________
> Matplotlib-users mailing list
> Mat...@li...
> https://lists.sourceforge.net/lists/listinfo/matplotlib-users
>
>
>
>
> ------------------------------------------------------------------------------
> Monitor 25 network devices or servers for free with OpManager!
> OpManager is web-based network management software that monitors
> network devices and physical & virtual servers, alerts via email & sms
> for fault. Monitor 25 devices for free with no restriction. Download now
> http://ad.doubleclick.net/ddm/clk/292181274;119417398;o
> _______________________________________________
> Matplotlib-users mailing list
> Mat...@li...
> https://lists.sourceforge.net/lists/listinfo/matplotlib-users
>
>

For my backend (nbagg), the order of the data determines the order of drawing. So in the following, the third diamond covers the first two in the first plot, but the first diamond covers them all in the second plot. Perhaps not as elegant as a matrix zorder, but can achieve the effect you are after. 
Cheers, Jody
fig, ax = plt.subplots(2,1)
x = np.arange(3)
y = 0.*x
ax[0].plot(x,y,'d',markersize=52)
ax[0].set_xlim(-10.,10.)
ax[1].plot(x[[2,1,0]],y[[2,1,0]],'d',markersize=52)
ax[1].set_xlim(-10.,10.)
> On Jun 23, 2015, at 9:44 AM, Benjamin Root <ben...@ou...> wrote:
> 
> I see what you are getting at. The issue is that artists are first sorted by the zorder and then drawn one at a time. The draw for a collection artist is an at-once operation, it can't (currently) be split out and interspersed with the draws from another artist. This is one of the major limitations for mplot3d, as it would be nice to compose a 3d scene properly so that everything is logically consistent.
> 
> I have actually been working on some changes that would allow one to sort the draws of individual elements of a collection, but I still haven't figured out a way to "break out" the elements with other collection elements in a way that doesn't break the current design or introduce major performance penalties. Maybe I'll figure something out during SciPy2015.
> 
> Cheers!
> Ben Root
> 
> 
> On Tue, Jun 23, 2015 at 5:44 AM, Simon Walker <s.r...@go... <mailto:s.r...@go...>> wrote:
> When multiple datasets are plotted on the same axis, the points overlay each other making it hard to see the points under the most recent ones. One way to avoid this is to give each point a random zorder, randomising its position in the z axis. This way, points from the first dataset may overly points from the last dataset.
> 
> This could be achieved nicely if the zorder keyword took an array so the random zorder values per point can be pre-computed, but currently it only accepts a single number for the whole dataset. Would this be a useful feature for others to have? How difficult would it be to implement?
> 
> Thanks,
> 
> Simon Walker
> ------------------------------------------------------------------------------
> Monitor 25 network devices or servers for free with OpManager!
> OpManager is web-based network management software that monitors
> network devices and physical & virtual servers, alerts via email & sms
> for fault. Monitor 25 devices for free with no restriction. Download now
> http://ad.doubleclick.net/ddm/clk/292181274;119417398;o <http://ad.doubleclick.net/ddm/clk/292181274;119417398;o>
> _______________________________________________
> Matplotlib-users mailing list
> Mat...@li... <mailto:Mat...@li...>
> https://lists.sourceforge.net/lists/listinfo/matplotlib-users <https://lists.sourceforge.net/lists/listinfo/matplotlib-users>
> 
> ------------------------------------------------------------------------------
> Monitor 25 network devices or servers for free with OpManager!
> OpManager is web-based network management software that monitors 
> network devices and physical & virtual servers, alerts via email & sms 
> for fault. Monitor 25 devices for free with no restriction. Download now
> http://ad.doubleclick.net/ddm/clk/292181274;119417398;o_______________________________________________
> Matplotlib-users mailing list
> Mat...@li...
> https://lists.sourceforge.net/lists/listinfo/matplotlib-users

I see what you are getting at. The issue is that artists are first sorted
by the zorder and then drawn one at a time. The draw for a collection
artist is an at-once operation, it can't (currently) be split out and
interspersed with the draws from another artist. This is one of the major
limitations for mplot3d, as it would be nice to compose a 3d scene properly
so that everything is logically consistent.
I have actually been working on some changes that would allow one to sort
the draws of individual elements of a collection, but I still haven't
figured out a way to "break out" the elements with other collection
elements in a way that doesn't break the current design or introduce major
performance penalties. Maybe I'll figure something out during SciPy2015.
Cheers!
Ben Root
On Tue, Jun 23, 2015 at 5:44 AM, Simon Walker <s.r...@go...>
wrote:
> When multiple datasets are plotted on the same axis, the points overlay
> each other making it hard to see the points under the most recent ones. One
> way to avoid this is to give each point a random zorder, randomising its
> position in the z axis. This way, points from the first dataset may overly
> points from the last dataset.
>
> This could be achieved nicely if the zorder keyword took an array so the
> random zorder values per point can be pre-computed, but currently it only
> accepts a single number for the whole dataset. Would this be a useful
> feature for others to have? How difficult would it be to implement?
>
> Thanks,
>
> Simon Walker
>
> ------------------------------------------------------------------------------
> Monitor 25 network devices or servers for free with OpManager!
> OpManager is web-based network management software that monitors
> network devices and physical & virtual servers, alerts via email & sms
> for fault. Monitor 25 devices for free with no restriction. Download now
> http://ad.doubleclick.net/ddm/clk/292181274;119417398;o
> _______________________________________________
> Matplotlib-users mailing list
> Mat...@li...
> https://lists.sourceforge.net/lists/listinfo/matplotlib-users
>

When multiple datasets are plotted on the same axis, the points overlay each other making it hard to see the points under the most recent ones. One way to avoid this is to give each point a random zorder, randomising its position in the z axis. This way, points from the first dataset may overly points from the last dataset.
This could be achieved nicely if the zorder keyword took an array so the random zorder values per point can be pre-computed, but currently it only accepts a single number for the whole dataset. Would this be a useful feature for others to have? How difficult would it be to implement?
Thanks,
Simon Walker