matplotlib-users Mailing List for matplotlib

I'd appreciate some pointers on how to get a barchart of the following
--8<---------------cut here---------------start------------->8---
date|name|empid|app|subapp|hours
20140101|A|0001|IIC|I1|2.5
20140101|A|0001|IIC|I2|3
20140101|A|0001|IIC|I3|4
20140101|A|0001|CAR|C1|2.5
20140101|A|0001|CAR|C2|3
20140101|A|0001|CAR|C3|2
20140101|A|0001|CAR|C4|2
--8<---------------cut here---------------end--------------->8---
I've got the above in a panda dataframe df and I'd like to plot them
as 
blue: 3 bars of IIC (I1-I3) of the hours, bar labelled with subapp and
hours on top of the bar
red: 4 bars of CAR (C1-C5) of the hours, bar labelled with subapp and
hours on top of the bar
on the y axis with the date on the x axis. 
 sivaram
 -- 

Hey matplotlib users,
Hi, I'm with Plotly <http://plot.ly>. We thought we'd let you know you can
convert matplotlib code to Plotly graphs and our Python API
<http://plot.ly>to make interactive, online graphs in Plotly. Your
graphs are styled with
D3, in the browser, and store your data too. Once you make a graph with the
API, you can edit it with a GUI, share it, and embed it.
Here is an example
translation<http://nbviewer.ipython.org/gist/arsenovic/8375182>,
in an IPython Notebook.
This feature is something still quite early and that we're exploring (GitHub
thread <https://github.com/plotly/python-api/issues/3>). So we'd very much
appreciate your advice and suggestions. As a new team, getting suggestions
from folks with insider knowledge goes a long way.
All my best,
Matt

2014年02月09日 2:29 GMT+01:00 garyr <ga...@fi...>:
> The script below labels both the left and right x-axes and shows a grid. Is
> there a way to force the horizontal grid lines to line up with the tic marks on
> the left axis (ax1)?
>
> import numpy as np
> import matplotlib.pyplot as plt
> fig = plt.figure()
> ax1 = fig.add_subplot(111)
> t = np.arange(0.01, 10.0, 0.01)
> s1 = np.exp(t)
> ax1.plot(t, s1, 'b-')
> ax2 = ax1.twinx()
> s2 = np.sin(2*np.pi*t)
> ax2.plot(t, s2, 'r')
> plt.grid()
> plt.show()
plt.grid() affects the current axes so calling it before creating the
second one should do. I think it would be more consistent if you used
the method ax1.grid() though.
Goyo

Hi Yi,
I also posted this as an answer to your question on SO, but here's how I'd
approach it.
It's simplest to just have a "DraggablePoints" class that accepts multiple
artists. That way you can synchronize which artist is "active" and ignore
the others.
As an example, based on yours:
import matplotlib.pyplot as plt
import matplotlib.patches as patches
class DraggablePoints(object):
 def __init__(self, artists, tolerance=5):
 for artist in artists:
 artist.set_picker(tolerance)
 self.artists = artists
 self.currently_dragging = False
 self.current_artist = None
 self.offset = (0, 0)
 for canvas in set(artist.figure.canvas for artist in self.artists):
 canvas.mpl_connect('button_press_event', self.on_press)
 canvas.mpl_connect('button_release_event', self.on_release)
 canvas.mpl_connect('pick_event', self.on_pick)
 canvas.mpl_connect('motion_notify_event', self.on_motion)
 def on_press(self, event):
 self.currently_dragging = True
 def on_release(self, event):
 self.currently_dragging = False
 self.current_artist = None
 def on_pick(self, event):
 if self.current_artist is None:
 self.current_artist = event.artist
 x0, y0 = event.artist.center
 x1, y1 = event.mouseevent.xdata, event.mouseevent.ydata
 self.offset = (x0 - x1), (y0 - y1)
 def on_motion(self, event):
 if not self.currently_dragging:
 return
 if self.current_artist is None:
 return
 dx, dy = self.offset
 self.current_artist.center = event.xdata + dx, event.ydata + dy
 self.current_artist.figure.canvas.draw()
if __name__ == '__main__':
 fig, ax = plt.subplots()
 ax.set(xlim=[-1, 2], ylim=[-1, 2])
 circles = [patches.Circle((0.32, 0.3), 0.2, fc='r', alpha=0.5),
 patches.Circle((0.3, 0.3), 0.2, fc='b', alpha=0.5)]
 for circ in circles:
 ax.add_patch(circ)
 dr = DraggablePoints(circles)
 plt.show()
Hope that helps!
-Joe
On Sat, Feb 8, 2014 at 7:32 PM, Yi <ide...@gm...> wrote:
> Hi Matplotlib community:
>
> In my case, I only want to drag one point each time. However, since the
> two points are heavily overlapping, dragging one point would cause another
> point to be dragged. How can I only drag one of the point? Thank you!
>
>
> from pylab import *from scipy import *import matplotlib.pyplot as pltimport matplotlib.patches as patches
>
> class DraggablePoint:
> def __init__(self, p):
> self.point = p
> self.press = None
>
> def connect(self):
> self.cidpress = self.point.figure.canvas.mpl_connect('button_press_event', self.button_press_event)
> self.cidrelease = self.point.figure.canvas.mpl_connect('button_release_event', self.button_release_event)
> self.cidmotion = self.point.figure.canvas.mpl_connect('motion_notify_event', self.motion_notify_event)
>
> def disconnect(self):
> 'disconnect all the stored connection ids'
> self.point.figure.canvas.mpl_disconnect(self.cidpress)
> self.point.figure.canvas.mpl_disconnect(self.cidrelease)
> self.point.figure.canvas.mpl_disconnect(self.cidmotion)
>
>
> def button_press_event(self,event):
> if event.inaxes != self.point.axes:
> return
> contains = self.point.contains(event)[0]
> if not contains: return
> self.press = self.point.center, event.xdata, event.ydata
>
>
> def button_release_event(self,event):
> self.press = None
> self.point.figure.canvas.draw()
>
> def motion_notify_event(self, event):
> if self.press is None: return
> if event.inaxes != self.point.axes: return
> self.point.center, xpress, ypress = self.press
> dx = event.xdata - xpress
> dy = event.ydata - ypress
> self.point.center = (self.point.center[0]+dx, self.point.center[1]+dy)
> print self.point.center
> self.point.figure.canvas.draw()
> if __name__ == '__main__':
> fig = plt.figure()
> ax = fig.add_subplot(111)
> ax.set_xlim(-1,2)
> ax.set_ylim(-1,2)
> circles = []
> circle1 = patches.Circle((0.32,0.3), 0.2, fc='r', alpha=0.5, picker=True)
> circle = patches.Circle((0.3,0.3), 0.2, fc='b', alpha=0.5, picker=True)
> circles.append(ax.add_patch(circle1))
> circles.append(ax.add_patch(circle))
> drs = []
> for c in circles:
> #print c.center[0]
> dr = DraggablePoint(c)
> dr.connect()
> drs.append(dr)
> plt.show()
>
>
>
>
> ------------------------------------------------------------------------------
> Managing the Performance of Cloud-Based Applications
> Take advantage of what the Cloud has to offer - Avoid Common Pitfalls.
> Read the Whitepaper.
>
> http://pubads.g.doubleclick.net/gampad/clk?id=121051231&iu=/4140/ostg.clktrk
> _______________________________________________
> Matplotlib-users mailing list
> Mat...@li...
> https://lists.sourceforge.net/lists/listinfo/matplotlib-users
>
>

The script below labels both the left and right x-axes and shows a grid. Is
there a way to force the horizontal grid lines to line up with the tic marks on
the left axis (ax1)?
import numpy as np
import matplotlib.pyplot as plt
fig = plt.figure()
ax1 = fig.add_subplot(111)
t = np.arange(0.01, 10.0, 0.01)
s1 = np.exp(t)
ax1.plot(t, s1, 'b-')
ax2 = ax1.twinx()
s2 = np.sin(2*np.pi*t)
ax2.plot(t, s2, 'r')
plt.grid()
plt.show()

Hi Matplotlib community:
In my case, I only want to drag one point each time. However, since the two
points are heavily overlapping, dragging one point would cause another
point to be dragged. How can I only drag one of the point? Thank you!
from pylab import *from scipy import *import matplotlib.pyplot as
pltimport matplotlib.patches as patches
class DraggablePoint:
 def __init__(self, p):
 self.point = p
 self.press = None
 def connect(self):
 self.cidpress =
self.point.figure.canvas.mpl_connect('button_press_event',
self.button_press_event)
 self.cidrelease =
self.point.figure.canvas.mpl_connect('button_release_event',
self.button_release_event)
 self.cidmotion =
self.point.figure.canvas.mpl_connect('motion_notify_event',
self.motion_notify_event)
 def disconnect(self):
 'disconnect all the stored connection ids'
 self.point.figure.canvas.mpl_disconnect(self.cidpress)
 self.point.figure.canvas.mpl_disconnect(self.cidrelease)
 self.point.figure.canvas.mpl_disconnect(self.cidmotion)
 def button_press_event(self,event):
 if event.inaxes != self.point.axes:
 return
 contains = self.point.contains(event)[0]
 if not contains: return
 self.press = self.point.center, event.xdata, event.ydata
 def button_release_event(self,event):
 self.press = None
 self.point.figure.canvas.draw()
 def motion_notify_event(self, event):
 if self.press is None: return
 if event.inaxes != self.point.axes: return
 self.point.center, xpress, ypress = self.press
 dx = event.xdata - xpress
 dy = event.ydata - ypress
 self.point.center = (self.point.center[0]+dx, self.point.center[1]+dy)
 print self.point.center
 self.point.figure.canvas.draw()
if __name__ == '__main__':
 fig = plt.figure()
 ax = fig.add_subplot(111)
 ax.set_xlim(-1,2)
 ax.set_ylim(-1,2)
 circles = []
 circle1 = patches.Circle((0.32,0.3), 0.2, fc='r', alpha=0.5, picker=True)
 circle = patches.Circle((0.3,0.3), 0.2, fc='b', alpha=0.5, picker=True)
 circles.append(ax.add_patch(circle1))
 circles.append(ax.add_patch(circle))
 drs = []
 for c in circles:
 #print c.center[0]
 dr = DraggablePoint(c)
 dr.connect()
 drs.append(dr)
 plt.show()