def draw_line(self, segments, ax, **kwargs):
key = (ax, kwargs.pop('key', self.keyfor(segments)))
ec = kwargs.pop('ec', 'k')
t = kwargs.pop('transform', None)
zorder = kwargs.pop('zorder', 1)
if key not in self.items:
l = LineCollection(segments)
ax.add_collection(l)
self.items[key] = dict(lines=l)
d = self.items[key]
l = d['lines']
l.set_segments(segments)
l.set_edgecolors(ec)
if t is not None:
l.set_transform(mplt.Affine2D(matrix=t) + ax.transData)
# u += drawer.draw_line(
# np.array([
# [0,10],
# [0,10]
# ]).T.reshape(1,2,2),
# ax
# )
return l,
def _generate_straight_edges(edges, pos, styles, *, ax):
N = len(edges)
if not N:
return None, None
proto_edge = next(iter(edges))
edge_pos = [None] * N
edge_indx = [None] * N
properties = {
k: [None] * N
for k in styles[proto_edge] if k in _VALID_EDGE_STYLE
}
for j, (u, v) in enumerate(edges):
edge_pos[j] = (pos[u], pos[v])
for key, values in properties.items():
values[j] = styles[(u, v)][key]
edge_indx[j] = (u, v)
key_map = {
'color': 'colors',
'width': 'linewidths',
'style': 'linestyle',
}
renamed_properties = {key_map[k]: v for k, v in properties.items()}
line_art = LineCollection(edge_pos,
transOffset=ax.transData,
zorder=1,
**renamed_properties)
line_art.set_transform(ax.transData)
return line_art, edge_indx
def changeVecteur(self, ech=1.0, col=None):
""" modifie les valeurs de vecteurs existants"""
self.drawVecteur(False)
if type(ech) == type((3, 4)):
if len(ech) >= 1:
ech = ech[0]
# previous object
obj = self.getObjFromType("vecteur")
if obj == None:
return
# change coordinates
dep, arr_old, ech_old = obj.getData()
arr = dep + (arr_old - dep) * ech / ech_old
# new object
lc1 = LineCollection(zip(dep, arr))
lc1.set_transform(self.transform)
if col == None:
col = wx.Color(0, 0, 255)
a = col.Get()
col = (a[0] / 255, a[1] / 255, a[2] / 255)
lc1.set_color(col)
obj = GraphicObject("vecteur", lc1, False, None)
obj.setData([dep, arr, ech])
self.addGraphicObject(obj)
self.cnv.collections[0] = lc1
self.redraw()
def shape(self, height, yrange, rotated):
g = rlg2mpl.Group()
trans = TransformScalePart(g.combined_transform)
y = height/2.0
segments = [[(x1,y),(x2,y)] for (x1,x2) in self.segments]
a = LineCollection(segments, edgecolor='k', facecolor='k')
a.set_linewidth(2)
g.add(a)
a.set_transform(g.combined_transform)
return g
def shape(self, height, yrange, rotated):
g = rlg2mpl.Group()
trans = TransformScalePart(g.combined_transform)
y = height / 2.0
segments = [[(x1, y), (x2, y)] for (x1, x2) in self.segments]
a = LineCollection(segments, edgecolor='k', facecolor='k')
a.set_linewidth(2)
g.add(a)
a.set_transform(g.combined_transform)
return g
def shape(self, height, yrange, rotated):
g = rlg2mpl.Group()
trans = TransformScalePart(g.combined_transform)
segment = [(0.1, 0), (0.9, 0)]
if rotated:
segment = [(y, x) for (x, y) in segment]
a = LineCollection([segment], colors=self.cvalues, offsets=self.offsets, transOffset=g.combined_transform)
a.set_linewidth(3)
g.add(a)
a.set_transform(trans)
return g
def shape(self, height, yrange, rotated):
g = rlg2mpl.Group()
trans = TransformScalePart(g.combined_transform)
segment = [(.1,0),(.9,0)]
if rotated:
segment = [(y,x) for (x,y) in segment]
a = LineCollection([segment], colors=self.cvalues,
offsets=self.offsets, transOffset=g.combined_transform)
a.set_linewidth(3)
g.add(a)
a.set_transform(trans)
return g
def make_range_frame(self):
xline = [(self.xbounds[0], self.xpos), (self.xbounds[1], self.xpos)]
yline = [(self.ypos, self.ybounds[0]), (self.ypos, self.ybounds[1])]
range_lines = LineCollection(segments=[xline, yline],
linewidths=[self.linewidth],
colors=[self.color])
range_lines.set_transform(self.axes.transAxes)
range_lines.set_zorder(10)
return range_lines
def make_range_frame(self):
xminf, xmaxf = data_bounds_on_axis(self.axes.viewLim.intervalx, self.xbounds)
yminf, ymaxf = data_bounds_on_axis(self.axes.viewLim.intervaly, self.ybounds)
xline = [(xminf, 0), (xmaxf, 0)]
yline = [(0, yminf), (0, ymaxf)]
range_lines = LineCollection(segments=[xline, yline], linewidths=[self.linewidth], colors=[self.color])
range_lines.set_transform(self.axes.transAxes)
range_lines.set_zorder(10)
return range_lines
class MyCell(matplotlib.table.CustomCell):
""" Extending matplotlib tables.
Adapted from https://stackoverflow.com/a/53573651/505698
"""
def __init__(self, *args, visible_edges, **kwargs):
super().__init__(*args, visible_edges=visible_edges, **kwargs)
seg = np.array([[0.0, 0.0], [1.0, 0.0], [1.0, 1.0], [0.0, 1.0],
[0.0, 0.0]]).reshape(-1, 1, 2)
segments = np.concatenate([seg[:-1], seg[1:]], axis=1)
self.edgelines = LineCollection(segments,
edgecolor=kwargs.get("edgecolor"))
self._text.set_zorder(2)
self.set_zorder(1)
def set_transform(self, trans):
self.edgelines.set_transform(trans)
super().set_transform(trans)
def draw(self, renderer):
c = self.get_edgecolor()
self.set_edgecolor((1, 1, 1, 0))
super().draw(renderer)
self.update_segments(c)
self.edgelines.draw(renderer)
self.set_edgecolor(c)
def update_segments(self, color):
x, y = self.get_xy()
w, h = self.get_width(), self.get_height()
seg = np.array([[x, y], [x + w, y], [x + w, y + h], [x, y + h],
[x, y]]).reshape(-1, 1, 2)
segments = np.concatenate([seg[:-1], seg[1:]], axis=1)
self.edgelines.set_segments(segments)
self.edgelines.set_linewidth(self.get_linewidth())
colors = [
color if edge in self._visible_edges else (1, 1, 1, 0)
for edge in self._edges
]
self.edgelines.set_edgecolor(colors)
def get_path(self):
codes = [Path.MOVETO] + [Path.LINETO] * 3 + [Path.CLOSEPOLY]
return Path(
[[0.0, 0.0], [1.0, 0.0], [1.0, 1.0], [0.0, 1.0], [0.0, 0.0]],
codes,
readonly=True,
)
def make_range_frame (self):
rx = self.axes.get_xlim()
ry = self.axes.get_ylim()
px = pl.prctile ( self.x )
py = pl.prctile ( self.y )
if self.trim:
if px[2]-px[0]>1.5*(px[3]-px[1]):
px[0] = self.x[self.x>px[2]-1.5*(px[3]-px[1])].min()
if px[4]-px[2]>1.5*(px[3]-px[1]):
px[4] = self.x[self.x<px[2]+1.5*(px[3]-px[1])].min()
x = px-rx[0]
x /= rx[1]-rx[0]
y = py-ry[0]
y /= ry[1]-ry[0]
ex = .003
ey = .003
xline = [
[(x[0],0),(x[1],0)],
[(x[1],ey),(x[2]-ex,ey)],
[(x[2]+ex,ey),(x[3],ey)],
[(x[3],0),(x[4],0)]
]
yline = [
[(0,y[0]),(0,y[1])],
[(ex,y[1]),(ex,y[2]-ey)],
[(ex,y[2]+ey),(ex,y[3])],
[(0,y[3]),(0,y[4])]
]
widths = [1,1,1,1]
range_lines = LineCollection(
segments=pl.clip(xline+yline,0,1),
linewidths=widths+widths,
colors=[[0]*3]*2*len(widths) )
range_lines.set_transform ( self.axes.transAxes )
range_lines.set_zorder(10)
self.axes.get_xaxis().tick_bottom()
self.axes.get_yaxis().tick_left()
self.axes.set_xticks(px)
self.axes.set_yticks(py)
self.axes.tick_params ( width=0 )
return range_lines
def make_box_plot (self):
x = self.x
rx = self.axes.get_xlim()
ry = self.axes.get_ylim()
ex = self.offset*(rx[1]-rx[0])
ey = self.offset*(ry[1]-ry[0])
if self.vert == 1:
ex,ey = ey,ex
p = self.boxstats['main']
n = self.boxstats['notch']
f_lo,f_hi = self.boxstats['fliers']
if self.notch:
lines = [ [(x,p[0]),(x,p[1])],
[(x+ex,p[1]),(x+ex,n[0])],
[(x+ex,n[0]),(x-ex,p[2]-ey)],
[(x-ex,p[2]+ey),(x+ex,n[1])],
[(x+ex,n[1]),(x+ex,p[3])],
[(x,p[3]),(x,p[4])] ]
else:
lines = [ [(x,p[0]),(x,p[1])],
[(x+ex,p[1]),(x+ex,p[2]-ey)],
[(x+ex,p[2]+ey),(x+ex,p[3])],
[(x,p[3]),(x,p[4])] ]
lines = pl.array(lines)
if self.vert==1:
lines = pl.array([ pl.c_[l[:,1],l[:,0]] for l in lines ])
pt = self.axes.plot ( f_lo, [x]*len(f_lo), '.', color=self.color,
markersize=self.lw ) + \
self.axes.plot ( f_hi, [x]*len(f_hi), '.', color=self.color,
markersize=self.lw )
dummy = self.axes.plot ( [p[0],p[-1]],[x-ex,x+ex], '.', markersize=0 )
else:
pt = self.axes.plot ( [x]*len(f_lo), f_lo, '.', color=self.color,
markersize=1 ) + \
self.axes.plot ( [x]*len(f_hi), f_hi, '.', color=self.color,
markersize=1 )
dummy = self.axes.plot ( [x-ex,x+ex], [p[0],p[-1]], '.', markersize=0 )
box = LineCollection (
segments=lines,
linewidths=[self.lw]*lines.shape[0],
colors=[self.color]*lines.shape[0] )
box.set_transform ( self.axes.transData )
box.set_zorder(10)
return box, pt[0],dummy[0]
def make_range_frame(self):
xminf, xmaxf = data_bounds_on_axis(self.axes.viewLim.intervalx,
self.xbounds)
yminf, ymaxf = data_bounds_on_axis(self.axes.viewLim.intervaly,
self.ybounds)
xline = [(xminf, 0), (xmaxf, 0)]
yline = [(0, yminf), (0, ymaxf)]
range_lines = LineCollection(segments=[xline, yline],
linewidths=[self.linewidth],
colors=[self.color])
range_lines.set_transform(self.axes.transAxes)
range_lines.set_zorder(10)
return range_lines
def createVecteur(self, X, Y, U, V, ech=1., col=None):
""" modifie les valeurs de vecteurs existants"""
self.drawVecteur(False)
#print shape(X),shape(Y),shape(U),shape(V)
# new coordinates
#vm = mean(median(median(U)),median(median(V)));
#dmx = max(X[0,1]-X[0,0],Y[0,1]-Y[0,0])
u, v = U, V #/vm*dmx*ech/2
l = len(ravel(X))
dep = concatenate([X.reshape((l, 1)), Y.reshape((l, 1))], axis=1)
b = X + u
c = Y + v
arr = concatenate([b.reshape((l, 1)), c.reshape((l, 1))], axis=1)
lc1 = LineCollection(zip(dep, arr))
lc1.set_transform(self.transform)
obj = GraphicObject('vecteur', lc1, False, None)
obj.setData([dep, arr, ech])
self.addGraphicObject(obj)
if len(self.cnv.collections) > 0: self.cnv.collections[0] = lc1
else: self.cnv.collections = [lc1]
self.redraw()
def createVecteur(self, X, Y, U, V, ech=1.0, col=None):
""" modifie les valeurs de vecteurs existants"""
self.drawVecteur(False)
# print shape(X),shape(Y),shape(U),shape(V)
# new coordinates
# vm = mean(median(median(U)),median(median(V)));
# dmx = max(X[0,1]-X[0,0],Y[0,1]-Y[0,0])
u, v = U, V # /vm*dmx*ech/2
l = len(ravel(X))
dep = concatenate([X.reshape((l, 1)), Y.reshape((l, 1))], axis=1)
b = X + u
c = Y + v
arr = concatenate([b.reshape((l, 1)), c.reshape((l, 1))], axis=1)
lc1 = LineCollection(zip(dep, arr))
lc1.set_transform(self.transform)
obj = GraphicObject("vecteur", lc1, False, None)
obj.setData([dep, arr, ech])
self.addGraphicObject(obj)
if len(self.cnv.collections) > 0:
self.cnv.collections[0] = lc1
else:
self.cnv.collections = [lc1]
self.redraw()
def changeVecteur(self, ech=1., col=None):
""" modifie les valeurs de vecteurs existants"""
self.drawVecteur(False)
if type(ech) == type((3, 4)):
if len(ech) >= 1: ech = ech[0]
# previous object
obj = self.getObjFromType('vecteur')
if obj == None: return
#change coordinates
dep, arr_old, ech_old = obj.getData()
arr = dep + (arr_old - dep) * ech / ech_old
# new object
lc1 = LineCollection(zip(dep, arr))
lc1.set_transform(self.transform)
if col == None: col = wx.Color(0, 0, 255)
a = col.Get()
col = (a[0] / 255, a[1] / 255, a[2] / 255)
lc1.set_color(col)
obj = GraphicObject('vecteur', lc1, False, None)
obj.setData([dep, arr, ech])
self.addGraphicObject(obj)
self.cnv.collections[0] = lc1
self.redraw()
def _make_line_collection(segments,
cvals,
min_val,
max_val,
cmap,
line_width,
zorder=100):
"""Takes in parameters to make colorbased paths LineCollection.
:param segments: linesegments to be plotted
:type segments: 2D array or list
:param cvals: list corresponding to the segments
:type cvals: list
:param min_val: min normalization value
:type min_val: float
:param max_val: max normalization value
:type max_val: float
:param cmap: colorbar
:type cmap: str
:param line_width: width of the lineplotted.
:type line_width: float
:param zorder: plotting priority
:type zorder: int
:return:
"""
lc = LineCollection(segments,
cvals,
cmap=plt.get_cmap(cmap),
norm=plt.Normalize(0, max_val - min_val),
zorder=zorder)
lc.set_transform(ccrs.Geodetic())
lc.set_array(cvals)
lc.set_linewidth(line_width)
return lc
def initDomain(self):
# changement de la valeur des axes
grd = self.model.Aquifere.getFullGrid()
self.xlim = (grd['x0'], grd['x1'])
self.ylim = (grd['y0'], grd['y1'])
p, = pl.plot([0, 1], 'b')
self.transform = p.get_transform()
obj = GraphicObject('grille', p, True, None)
self.addGraphicObject(obj)
self.changeDomain()
# add basic vector as a linecollection
dep = rand(2, 2) * 0.
arr = dep * 1.
ech = 1.
lc1 = LineCollection(zip(dep, arr))
lc1.set_transform(self.transform)
pl.setp(lc1, linewidth=.5)
self.cnv.collections = [lc1]
#self.cnv.add_patch(lc1);
obj = GraphicObject('vecteur', lc1, False, None)
obj.setData([dep, arr, ech])
self.addGraphicObject(obj)
self.draw()
def initDomain(self):
# changement de la valeur des axes
grd = self.model.Aquifere.getFullGrid()
self.xlim = (grd["x0"], grd["x1"])
self.ylim = (grd["y0"], grd["y1"])
p, = pl.plot([0, 1], "b")
self.transform = p.get_transform()
obj = GraphicObject("grille", p, True, None)
self.addGraphicObject(obj)
self.changeDomain()
# add basic vector as a linecollection
dep = rand(2, 2) * 0.0
arr = dep * 1.0
ech = 1.0
lc1 = LineCollection(zip(dep, arr))
lc1.set_transform(self.transform)
pl.setp(lc1, linewidth=0.5)
self.cnv.collections = [lc1]
# self.cnv.add_patch(lc1);
obj = GraphicObject("vecteur", lc1, False, None)
obj.setData([dep, arr, ech])
self.addGraphicObject(obj)
self.draw()
def plot_day_summary2_ohlc(
ax,
opens,
highs,
lows,
closes,
ticksize=4,
colorup='k',
colordown='r',
):
"""Represent the time, open, high, low, close as a vertical line
ranging from low to high. The left tick is the open and the right
tick is the close.
*opens*, *highs*, *lows* and *closes* must have the same length.
NOTE: this code assumes if any value open, high, low, close is
missing (*-1*) they all are missing
Parameters
----------
ax : `Axes`
an Axes instance to plot to
opens : sequence
sequence of opening values
highs : sequence
sequence of high values
lows : sequence
sequence of low values
closes : sequence
sequence of closing values
ticksize : int
size of open and close ticks in points
colorup : color
the color of the lines where close >= open
colordown : color
the color of the lines where close < open
Returns
-------
ret : list
a list of lines added to the axes
"""
_check_input(opens, highs, lows, closes)
rangeSegments = [((i, low), (i, high))
for i, low, high in zip(xrange(len(lows)), lows, highs)
if low != -1]
# the ticks will be from ticksize to 0 in points at the origin and
# we'll translate these to the i, close location
openSegments = [((-ticksize, 0), (0, 0))]
# the ticks will be from 0 to ticksize in points at the origin and
# we'll translate these to the i, close location
closeSegments = [((0, 0), (ticksize, 0))]
offsetsOpen = [(i, open) for i, open in zip(xrange(len(opens)), opens)
if open != -1]
offsetsClose = [(i, close) for i, close in zip(xrange(len(closes)), closes)
if close != -1]
scale = ax.figure.dpi * (1.0 / 72.0)
tickTransform = Affine2D().scale(scale, 0.0)
colorup = mcolors.to_rgba(colorup)
colordown = mcolors.to_rgba(colordown)
colord = {True: colorup, False: colordown}
colors = [
colord[open < close] for open, close in zip(opens, closes)
if open != -1 and close != -1
]
useAA = 0, # use tuple here
lw = 1, # and here
rangeCollection = LineCollection(
rangeSegments,
colors=colors,
linewidths=lw,
antialiaseds=useAA,
)
openCollection = LineCollection(
openSegments,
colors=colors,
antialiaseds=useAA,
linewidths=lw,
offsets=offsetsOpen,
transOffset=ax.transData,
)
openCollection.set_transform(tickTransform)
closeCollection = LineCollection(
closeSegments,
colors=colors,
antialiaseds=useAA,
linewidths=lw,
offsets=offsetsClose,
transOffset=ax.transData,
)
closeCollection.set_transform(tickTransform)
minpy, maxx = (0, len(rangeSegments))
miny = min([low for low in lows if low != -1])
maxy = max([high for high in highs if high != -1])
corners = (minpy, miny), (maxx, maxy)
ax.update_datalim(corners)
ax.autoscale_view()
# add these last
ax.add_collection(rangeCollection)
ax.add_collection(openCollection)
ax.add_collection(closeCollection)
return rangeCollection, openCollection, closeCollection
def plot_day_summary2(ax, opens, closes, highs, lows, ticksize=4,
colorup='k', colordown='r',
):
"""
Represent the time, open, close, high, low as a vertical line
ranging from low to high. The left tick is the open and the right
tick is the close.
ax : an Axes instance to plot to
ticksize : size of open and close ticks in points
colorup : the color of the lines where close >= open
colordown : the color of the lines where close < open
return value is a list of lines added
"""
# note this code assumes if any value open, close, low, high is
# missing they all are missing
rangeSegments = [ ((i, low), (i, high)) for i, low, high in zip(xrange(len(lows)), lows, highs) if low != -1 ]
# the ticks will be from ticksize to 0 in points at the origin and
# we'll translate these to the i, close location
openSegments = [ ((-ticksize, 0), (0, 0)) ]
# the ticks will be from 0 to ticksize in points at the origin and
# we'll translate these to the i, close location
closeSegments = [ ((0, 0), (ticksize, 0)) ]
offsetsOpen = [ (i, open) for i, open in zip(xrange(len(opens)), opens) if open != -1 ]
offsetsClose = [ (i, close) for i, close in zip(xrange(len(closes)), closes) if close != -1 ]
scale = ax.figure.dpi * (1.0/72.0)
tickTransform = Affine2D().scale(scale, 0.0)
r,g,b = colorConverter.to_rgb(colorup)
colorup = r,g,b,1
r,g,b = colorConverter.to_rgb(colordown)
colordown = r,g,b,1
colord = { True : colorup,
False : colordown,
}
colors = [colord[open<close] for open, close in zip(opens, closes) if open!=-1 and close !=-1]
assert(len(rangeSegments)==len(offsetsOpen))
assert(len(offsetsOpen)==len(offsetsClose))
assert(len(offsetsClose)==len(colors))
useAA = 0, # use tuple here
lw = 1, # and here
rangeCollection = LineCollection(rangeSegments,
colors = colors,
linewidths = lw,
antialiaseds = useAA,
)
openCollection = LineCollection(openSegments,
colors = colors,
antialiaseds = useAA,
linewidths = lw,
offsets = offsetsOpen,
transOffset = ax.transData,
)
openCollection.set_transform(tickTransform)
closeCollection = LineCollection(closeSegments,
colors = colors,
antialiaseds = useAA,
linewidths = lw,
offsets = offsetsClose,
transOffset = ax.transData,
)
closeCollection.set_transform(tickTransform)
minpy, maxx = (0, len(rangeSegments))
miny = min([low for low in lows if low !=-1])
maxy = max([high for high in highs if high != -1])
corners = (minpy, miny), (maxx, maxy)
ax.update_datalim(corners)
ax.autoscale_view()
# add these last
ax.add_collection(rangeCollection)
ax.add_collection(openCollection)
ax.add_collection(closeCollection)
return rangeCollection, openCollection, closeCollection
class Visualisation(FigureCanvasWxAgg):
def __init__(self, gui):
self.fig = pl.figure() #(9,8), 90)
FigureCanvasWxAgg.__init__(self, gui, -1, self.fig)
self.xlim, self.ylim, self.dataon = (), (), False
# c'est la GUI e tle modele
self.gui, self.core = gui, gui.core
# polygone d'interaction sur une zone (pour pouvoir la modifier)
self.polyInteract = None
# liste de variables, sert pour la GUI et le combobox sur les variables
self.listeNomVar = []
for mod in self.core.modelList:
for k in gui.linesDic[mod].keys():
self.listeNomVar.extend(gui.linesDic[mod][k])
self.curVar, self.curContour = None, 'Charge' # variable courante selectionne
self.curMedia, self.curOri, self.curPlan, self.curGroupe = 0, 'Z', 0, None
# variable pour savoir si on est en cours de tracage d'une zone
self.typeZone = -1
# coordonnees et zone de la zone que l'on est en train de creer
self.curZone = None # objet graphique (ligne, point, rect..)
self.x1, self.y1 = [], []
self.tempZoneVal = [] # liste de values pour polyV
self.calcE = 0
self.calcT = 0
self.calcR = 0
# dit si calcule effectue ou non
# dictionnaire qui est compose des variables de l'Aquifere
# a chaque variable est associe une liste de zones
self.listeZone, self.listeZoneText, self.listeZmedia = {}, {}, {}
for i in range(len(self.listeNomVar)):
#print self.listeNomVar[i]
self.listeZone[self.listeNomVar[i]] = []
self.listeZoneText[self.listeNomVar[i]] = []
self.listeZmedia[self.listeNomVar[i]] = []
# toolbar de la visu, de type NavigationToolbar2Wx
self.toolbar = NavigationToolbar2Wx(self)
self.toolbar.Realize()
# ajout du subplot a la figure
self.cnv = self.fig.add_axes([.05, .05, .9,
.88]) #left,bottom, wide,height
self.toolbar.update()
self.pos = self.mpl_connect('motion_notify_event', self.onPosition)
# create teh major objects:
self.Contour, self.ContourF, self.ContourLabel, self.Vector = None, None, None, None
self.Grid, self.Particles, self.Image, self.Map = None, None, None, None
#####################################################################
# Divers accesseur/mutateurs
#####################################################################
def GetToolBar(self):
return self.toolbar
def getcurVisu(self):
return [self.curGroupe, self.curNom, self.curObj]
def onPosition(self, evt):
self.gui.onPosition(' x: ' + str(evt.xdata)[:6] + ' y: ' +
str(evt.ydata)[:6])
def delAllObjects(self):
for v in self.listeZone:
self.listeZone[v] = []
self.listeZoneText[v] = []
self.cnv.lines = []
self.cnv.collections = []
self.cnv.artists = []
self.cnv.images = []
self.cnv.cla()
self.draw()
def setVisu(self, core):
"""creer les objets graphiques a partir des caracteristiques d'un modele
importe.
creer les zones avec setAllzones, puis le contour et les vectors ecoult,
les lignes etle contour pour tracer, contour pour reaction
depend de l'etat du systeme de la liste graphique
comme ca tout ca pourra etre visualise sans faire de nouveau calcul
"""
self.delAllObjects()
for mod in self.core.modelList:
self.setAllZones(core.diczone[mod].dic)
self.initDomain()
self.draw()
def setDataOn(self, bool):
"""definit l'affichage ou non des donnees qaund contour"""
self.dataon = bool
def redraw(self):
#self.cnv.set_xlim(self.xlim)
#self.cnv.set_ylim(self.ylim)
self.draw()
# def changeTitre(self,titre):
# s='';ori=self.curOri
# if ori in ['X','Y','Z']:
# plan=self.curPlan;
# x1,y1 = self.model.Aquifere.getXYticks()
# zl = self.model.Aquifere.getParm('zList')
# if ori=='Z': s=' Z = '+ str(zl[plan])
# if ori=='X': s=' X = '+ str(x1[plan])
# if ori=='Y': s=' Y = '+ str(y1[plan])
# pl.title(self.traduit(str(titre))+s[:9],fontsize=20)
def createAndShowObject(self, dataM, dataV, opt, value=None, color=None):
"""create the Contour, Vector, opt is contour or vector
"""
if dataM == None: self.drawContour(False)
else: self.createContour(dataM, value, color)
if dataV == None: self.drawVector(False)
else: self.createVector(dataV)
def drawObject(self, typObj, bool):
if typObj == 'Map' and self.Map == None and bool == False: return
exec('self.draw' + typObj + '(' + str(bool) + ')')
def changeObject(self, groupe, name, value, color):
if name == 'Grid': self.changeGrid(color)
elif name == 'Particles':
self.changeParticles(value=value, color=color)
elif name == 'Veloc-vect':
self.changeVector(value, color)
#elif name=='Visible': self.changeData(value,color)
else:
self.changeContour(value, color)
#####################################################################
# Gestion de l'affichage de la grid/map
#####################################################################
# methode qui change la taille du domaine d'etude (les values de l'axe
# de la figure matplotlib en fait) et la taille des cellules d'etude
def initDomain(self):
# change value of the axes
grd = self.core.addin.getFullGrid()
self.xlim = (grd['x0'], grd['x1'])
self.ylim = (grd['y0'], grd['y1'])
p, = pl.plot([0, 1], 'b')
p.set_visible(False)
self.transform = p.get_transform()
self.cnv.set_xlim(self.xlim)
self.cnv.set_ylim(self.ylim)
self.createGrid()
# add basic vector as a linecollection
dep = rand(2, 2) * 0.
arr = dep * 1.
self.Vector = LineCollection(zip(dep, arr))
self.Vector.set_transform(self.transform)
self.Vector.set_visible(False)
#pl.setp(lc,linewidth=.5);
self.cnv.collections.append(self.Vector)
self.Vector.data = [0, 0, None, None]
# def changeDomain(self):
# self.changeAxesOri('Z',0)
#
def changeAxesOri(self, ori):
# change orientation de la visu
zb = self.core.Zblock
zlim = (amin(zb), amax(zb))
if ori == 'Z':
self.cnv.set_xlim(self.xlim)
self.cnv.set_ylim(self.ylim)
elif ori == 'X':
self.cnv.set_xlim(self.ylim)
self.cnv.set_ylim(zlim)
elif ori == 'Y':
self.cnv.set_xlim(self.xlim)
self.cnv.set_ylim(zlim)
self.draw()
def createGrid(self, col=None):
if self.Grid == None:
col = (.6, .6, .6)
self.Grid = [0, 0, col]
#self.cnv.collections=[0,0];
else:
for i in range(2):
self.Grid[i].set_visible(False)
if col == None: col = self.Grid[2]
else: self.Grid[2] = col
#print 'create grid',self.Grid,col
nx, ny, xt, yt = getXYvects(self.core)
#print 'visu,grid',nx,ny,xt,yt
if len(self.cnv.collections) < 2: self.cnv.collections = [0, 0]
l = len(ravel(xt))
dep = concatenate([xt.reshape((l, 1)), ones((l, 1)) * min(yt)], axis=1)
arr = concatenate([xt.reshape((l, 1)), ones((l, 1)) * max(yt)], axis=1)
self.Grid[0] = LineCollection(zip(dep, arr))
self.cnv.collections[0] = self.Grid[0]
l = len(ravel(yt))
dep = concatenate([ones((l, 1)) * min(xt), yt.reshape((l, 1))], axis=1)
arr = concatenate([ones((l, 1)) * max(xt), yt.reshape((l, 1))], axis=1)
self.Grid[1] = LineCollection(zip(dep, arr))
self.cnv.collections[1] = self.Grid[1]
for i in [0, 1]:
self.Grid[i].set_transform(self.transform)
self.Grid[i].set_color(col)
self.redraw()
def drawGrid(self, bool): # works only to remove not to recreate
col = self.Grid[2]
for i in [0, 1]:
self.Grid[i].set_visible(bool)
self.Grid[i].set_color(col)
self.redraw()
def changeGrid(self, color):
a = color.Get()
col = (a[0] / 255, a[1] / 255, a[2] / 255)
for i in [0, 1]:
self.Grid[i].set_color(col)
self.Grid[2] = col
self.redraw()
#####################################################################
# Affichage d'une variable sous forme d'image
#####################################################################
# l'image se met en position 1 dans la liste des images
def createMap(self):
file = self.gui.map
mat = Im.imread(file)
org = 'upper'
ext = (self.xlim[0], self.xlim[1], self.ylim[0], self.ylim[1])
self.Map = pl.imshow(mat,
origin=org,
extent=ext,
aspect='auto',
interpolation='nearest')
self.cnv.images = [self.Map] #
self.cnv.images[0].set_visible(True)
self.redraw()
def drawMap(self, bool):
if self.Map == None: self.createMap()
# self.Map.set_visible(bool)
self.cnv.images = [self.Map] #
self.cnv.images[0].set_visible(bool)
self.redraw()
def createImage(self, data):
#print 'vis img',len(xt),len(yt),shape(mat)
X, Y, Z = data
image = pl.pcolormesh(X, Y, Z) #,norm='Normalize')
self.cnv.images = [image]
self.redraw()
def drawImage(self, bool):
if len(self.cnv.images) > 0:
self.cnv.images[0].set_visible(bool)
self.redraw()
#####################################################################
# Gestion de l'affichage des contours
#####################################################################
def createContour(self, data, value=None, col=None):
""" calcul des contour sa partir de value : value[0] : min
[1] : max, [2] nb contours, [3] decimales, [4] : 'lin' log' ou 'fix',
si [4]:fix, alors [5] est la serie des values de contours"""
X, Y, Z = data
#print 'visu controu',value,col
self.cnv.collections = self.cnv.collections[:3]
self.cnv.artists = []
V = 11
Zmin = amin(amin(Z))
Zmax = amax(amax(Z * (Z < 1e5)))
if Zmax == Zmin: # test min=max -> pas de contour
self.gui.onMessage(' values all equal to ' + str(Zmin))
return
if value == None:
value = [Zmin, Zmax, (Zmax - Zmin) / 10., 2, 'auto', []]
# adapter le namebre et la value des contours
val2 = [float(a) for a in value[:3]]
if value[4] == 'log': # cas echelle log
n = int((log10(val2[1]) - log10(max(val2[0], 1e-4))) / val2[2]) + 1
V = logspace(log10(max(val2[0], 1e-4)), log10(val2[1]), n)
elif (value[4]
== 'fix') and (value[5] != None): # fixes par l'utilisateur
V = value[5] * 1
V.append(V[-1] * 2.)
n = len(V)
elif value[4] == 'lin': # cas echelle lineaire
n = int((val2[1] - val2[0]) / val2[2]) + 1
V = linspace(val2[0], val2[1], n)
else: # cas automatique
n = 11
V = linspace(Zmin, Zmax, n)
# ONE DIMENSIONAL
r, c = shape(X)
if r == 1:
X = concatenate([X, X])
Y = concatenate([Y - Y * .45, Y + Y * .45])
Z = concatenate([Z, Z])
Z2 = ma.masked_where(Z.copy() > 1e5, Z.copy())
#print value,n,V
# definir les couleurs des contours
if col == None: # or (col==[(0,0,0),(0,0,0),(0,0,0),10]):
cf = pl.contourf(pl.array(X), pl.array(Y), Z2, V)
c = pl.contour(pl.array(X), pl.array(Y), Z2, V)
col = [(0, 0, 255), (0, 255, 0), (255, 0, 0), 10]
else:
r, g, b = [], [], []
lim=((0.,1.,0.,0.),(.1,1.,0.,0.),(.25,.8,0.,0.),(.35,0.,.8,0.),(.45,0.,1.,0.),\
(.55,0.,1.,0.),(.65,0.,.8,0.),(.75,0.,0.,.8),(.9,0.,0.,1.),(1.,0.,0.,1.))
for i in range(len(lim)):
c1 = lim[i][1] * col[0][0] / 255. + lim[i][2] * col[1][
0] / 255. + lim[i][3] * col[2][0] / 255.
r.append((lim[i][0], c1, c1))
c2 = lim[i][1] * col[0][1] / 255. + lim[i][2] * col[1][
1] / 255. + lim[i][3] * col[2][1] / 255.
g.append((lim[i][0], c2, c2))
c3 = lim[i][1] * col[0][2] / 255. + lim[i][2] * col[1][
2] / 255. + lim[i][3] * col[2][2] / 255.
b.append((lim[i][0], c3, c3))
cdict = {'red': r, 'green': g, 'blue': b}
my_cmap = mpl.colors.LinearSegmentedColormap(
'my_colormap', cdict, 256)
cf = pl.contourf(pl.array(X), pl.array(Y), Z2, V, cmap=my_cmap)
c = pl.contour(pl.array(X), pl.array(Y), Z2, V, cmap=my_cmap)
#print col[3]
for c0 in cf.collections:
c0.set_alpha(int(col[3]) / 100.)
#print cl
if value == None: fmt = '%1.3f'
else: fmt = '%1.' + str(value[3]) + 'f'
cl = pl.clabel(c, color='black', fontsize=9, fmt=fmt)
self.Contour = c
self.ContourF = cf
self.ContourLabel = cl
self.Contour.data = data
self.redraw()
def changeContour(self, value, col):
""" modifie les values d'un contour existant"""
self.drawContour(False)
self.createContour(self.Contour.data, value, col)
def drawContour(self, bool):
self.cnv.collections = self.cnv.collections[:3]
self.cnv.artists = []
self.draw()
#~ for c in self.Contour.collections :c.set_visible(False)
#~ for c in self.ContourF.collections :c.set_visible(False)
#~ for a in self.ContourLabel: a.set_visible(False)
#~ #self.cnv.collections = self.cnv.collections[:3]
#~ self.redraw()
#####################################################################
# Gestion de l'affichage de vectors
#####################################################################
"""vector has been created as the first item of lincollection list
during domain intialization"""
def createVector(self, data):
X, Y, U, V = data
""" modifie les values de vectors existants"""
if self.Vector.data[3] == None: #first vector no color
ech = 1.
col = (0, 0, 1)
else:
a, b, ech, col = self.Vector.data
self.drawVector(False)
l = len(ravel(X))
dep = concatenate([X.reshape((l, 1)), Y.reshape((l, 1))], axis=1)
b = X + U * ech
c = Y + V * ech
arr = concatenate([b.reshape((l, 1)), c.reshape((l, 1))], axis=1)
self.Vector = LineCollection(zip(dep, arr))
self.Vector.set_transform(self.transform)
self.Vector.set_color(col)
if len(self.cnv.collections) > 2: self.cnv.collections[2] = self.Vector
else: self.cnv.collections.append(self.Vector)
self.Vector.set_visible(True)
self.Vector.data = [dep, arr, ech, col]
#print self.Vector.data
self.redraw()
def drawVector(self, bool):
""" dessine les vectors vitesse a partir de x,y,u,v et du
booleen qui dit s'il faut dessiner ou non """
self.Vector.set_visible(bool)
self.redraw()
def changeVector(self, ech, col=wx.Color(0, 0, 255)):
""" modifie les values de vectors existants"""
#self.drawVector(False)
ech = float(ech)
#change coordinates
dep, arr_old, ech_old, col_old = self.Vector.data
#print shape(dep),shape(arr_old),ech,ech_old
arr = dep + (arr_old - dep) * ech / ech_old
# new object
#self.Vector = LineCollection(zip(dep,arr))
self.Vector.set_segments(zip(dep, arr))
#self.Vector.set_transform(self.transform)
a = col.Get()
col = (a[0] / 255, a[1] / 255, a[2] / 255)
self.Vector.set_color(col)
self.Vector.set_visible(True)
#self.cnv.collections[2]=self.Vector
self.Vector.data = [dep, arr, ech, col]
self.redraw()
#####################################################################
# Gestion de l'affichage de particules
#####################################################################
def startParticles(self):
if self.Particles != None:
self.partVisible(False)
self.Particles = {
'line': [],
'txt': [],
'data': [],
'color': wx.Color(255, 0, 0)
}
self.mpl_disconnect(self.toolbar._idPress)
self.mpl_disconnect(self.toolbar._idRelease)
self.mpl_disconnect(self.toolbar._idDrag)
# on capte le clic gauche de la souris
self.m3 = self.mpl_connect('button_press_event', self.mouseParticles)
self.stop = False
#self.createParticles()
#wx.EVT_LEAVE_WINDOW(self,self.finParticules) # arrete particules qd on sort de visu
def mouseParticles(self, evt):
#test pour savoir si le curseur est bien dans les axes de la figure
if self.stop: return
if evt.inaxes is None: return
if evt.button == 1:
[xp, yp, tp] = self.core.addin.calcParticle(evt.xdata, evt.ydata)
#print xp,yp,tp
self.updateParticles(xp, yp, tp)
elif evt.button == 3:
self.mpl_disconnect(self.m3)
self.stop = True
self.gui.actions('zoneEnd')
def updateParticles(self, X, Y, T, freq=10):
""" rajouter une ligne dans le groupe de particules"""
ligne, = pl.plot(pl.array(X), pl.array(Y), 'r')
if freq > 0:
tx, ty, tt = X[0::freq], Y[0::freq], T[0::freq]
txt = []
for i in range(len(tx)):
a = str(tt[i])
b = a.split('.')
ln = max(4, len(b[0]))
txt.append(pl.text(tx[i], ty[i], a[:ln], fontsize='8'))
self.Particles['line'].append(ligne)
self.Particles['txt'].append(txt)
self.Particles['data'].append((X, Y, T))
self.gui_repaint() # bug matplotlib v2.6 for direct draw!!!
self.draw()
def drawParticles(self, bool, value=None):
if self.Particles == None: return
self.partVisible(bool)
self.gui_repaint()
self.draw()
def changeParticles(self, value=None, color=wx.Color(255, 0, 0)):
self.partVisible(False)
self.Particles['color'], self.Particles['txt'] = color, []
for i, data in enumerate(self.Particles['data']):
X, Y, T = data
tx, ty, tt = self.ptsPartic(X, Y, T, float(value))
txt = []
for i in range(len(tx)):
a = str(tt[i])
b = a.split('.')
ln = max(4, len(b[0]))
txt.append(pl.text(tx[i], ty[i], a[:ln], fontsize='8'))
self.Particles['txt'].append(txt)
self.partVisible(True)
self.gui_repaint()
self.draw()
def partVisible(self, bool):
a = self.Particles['color'].Get()
color = (a[0] / 255, a[1] / 255, a[2] / 255)
for line in self.Particles['line']:
line.set_visible(bool)
line.set_color(color)
for points in self.Particles['txt']:
for txt in points:
txt.set_visible(bool)
def ptsPartic(self, X, Y, T, dt):
#tx,ty,tt,i1=iphtC1.ptsLigne(X,Y,T,dt);
tmin = amin(T)
tmax = amax(T)
t1 = linspace(tmin, tmax, int((tmax - tmin) / dt))
f = interp1d(T, X)
xn = f(t1)
f = interp1d(T, Y)
yn = f(t1)
return xn, yn, t1
#####################################################################
# Gestion des zones de la visu
#####################################################################
# affichage de toutes les zones d'une variable
def showVar(self, var, media):
self.setUnvisibleZones()
self.curVar, self.curMedia = var, media
for i in range(len(self.listeZone[var])):
#print 'vis showvar',self.listeZmedia[var][i]
if (media in self.listeZmedia[var][i]) or (media == -1):
self.listeZone[var][i].set_visible(True)
self.visibleText(self.listeZoneText[var][i], True)
#self.changeTitre(var)
self.redraw()
def showData(self, liForage, liData):
self.setUnvisibleZones()
self.curVar = 'data'
self.listeZoneText['data'] = []
for zone in self.listeZone['Forages']:
zone.set_visible(True)
lZone = self.model.Aquifere.getZoneList('Forages')
txt = []
for z in lZone:
x, y = zip(*z.getXy())
name = z.getNom()
if name in liForage:
ind = liForage.index(name)
txt.append(
pl.text(mean(x), mean(y), name + '\n' + str(liData[ind])))
obj = GraphicObject('zoneText', txt, True, None)
self.addGraphicObject(obj)
self.redraw()
def changeData(self, taille, col):
obj = self.listeZoneText['data'][0].getObject()
for txt in obj:
txt.set_size(taille)
txt.set_color(col)
def getcurZone(self):
return self.curZone
def setcurZone(self, zone):
self.curZone = zone
# methode qui efface toutes les zones de toutes les variables
def setUnvisibleZones(self):
for v in self.listeZone:
for zone in self.listeZone[v]:
zone.set_visible(False)
for txt in self.listeZoneText[v]:
if type(txt) == type([5, 6]):
for t in txt:
t.set_visible(False)
else:
txt.set_visible(False)
# methode appelee par la GUI lorsqu'on veut creer une nouvelle zone
def setZoneReady(self, typeZone, curVar):
self.typeZone = typeZone
self.curVar = curVar
self.tempZoneVal = []
# on deconnecte la toolbar pour activer la formaiton de zones
self.mpl_disconnect(self.toolbar._idPress)
self.mpl_disconnect(self.toolbar._idRelease)
self.mpl_disconnect(self.toolbar._idDrag)
# on capte le clic gauche de la souris
self.m1 = self.mpl_connect('button_press_event', self.mouse_clic)
def setZoneEnd(self, evt):
# on informe la GUI qui informera le model
xv, yv = self.getcurZone().get_xdata(), self.getcurZone().get_ydata()
if len(self.tempZoneVal) > 1: xy = zip(xv, yv, self.tempZoneVal)
else: xy = zip(xv, yv)
# effacer zone pour si cancel, remettre de l'ordre
self.curZone.set_visible(False)
self.curZone = None
self.x1, self.y1 = [], []
self.gui.addBox.onZoneCreate(self.typeZone, xy)
def addZone(self, media, name, val, coords, visible=True):
""" ajout de la zone et du texte (name+value) sur visu
"""
#print 'visu',coords
a = zip(*coords)
txt = []
#print name,a
if len(a) == 0: return
if len(a) == 2: x, y = a
elif len(a) == 3: x, y, z = a
if len(x) == 1:
zone = Line2D(x, y, marker='+', markersize=10, markeredgecolor='r')
else:
zone = Line2D(x, y)
zone.verts = coords
zone.set_visible(visible)
if type(media) != type([2]): media = [int(media)]
self.curMedia = media
self.cnv.add_line(zone)
if self.typeZone == "POLYV" or len(coords[0]) == 3:
txt = [
pl.text(
mean(x) * .1 + x[0] * .9,
mean(y) * .1 + y[0] * .9, name + '\n' + str(val)[:16])
]
for i in range(len(x)):
t = pl.text(x[i], y[i], str(z[i]))
t.set_visible(visible)
txt.append(t)
else:
txt = pl.text(
mean(x) * .1 + x[0] * .9,
mean(y) * .1 + y[0] * .9, name + '\n' + str(val)[:16])
self.listeZone[self.curVar].append(zone)
self.listeZmedia[self.curVar].append(media)
self.listeZoneText[self.curVar].append(txt)
if visible: self.redraw()
def delZone(self, Variable, ind):
"""methode de suppression de la zone d'indice ind de Variable
"""
if self.listeZone.has_key(Variable) == False: return
if len(self.listeZone[Variable]) > ind:
self.listeZone[Variable][ind].set_visible(False)
self.visibleText(self.listeZoneText[Variable][ind], False)
self.listeZone[Variable][ind:ind + 1] = []
self.listeZoneText[Variable][ind:ind + 1] = []
self.listeZmedia[Variable].pop(ind)
self.redraw()
def visibleText(self, text, bool):
if type(text) == type([5, 6]):
for t in text:
t.set_visible(bool)
else:
text.set_visible(bool)
def delAllZones(self, Variable):
lz = self.listeZone[Variable]
for i in range(len(lz)):
lz[i].setVisible(False)
self.listeZoneText[Variable][i].set_visible(False)
self.listeZone[Variable] = []
self.listeZmedia[Variable] = []
self.listeZoneText[Variable] = []
self.redraw()
def modifValZone(self, nameVar, ind, val, xy):
"""modify the value (or list of value) for the zone nameVar
the text contains name et value"""
def modifZoneAttr(self, nameVar, ind, val, media, xy):
# modify xy
zone = self.listeZone[nameVar][ind]
if len(xy[0]) == 3: x, y, z = zip(*xy)
else: x, y = zip(*xy)
zone.set_data(x, y)
# modify media
if type(media) != type([2]): media = [int(media)]
self.listeZmedia[nameVar][ind] = media
# modify text
textObj = self.listeZoneText[nameVar][ind]
if type(textObj) == type([2, 3]):
name = pl.getp(textObj[0], 'text').split('\n')[0]
pl.setp(textObj[0], text=name + '\n' + str(val)[:16])
for i in range(len(z)):
pl.setp(textObj[i + 1], text=str(z[i]))
else:
name = pl.getp(textObj, 'text').split('\n')[0]
pl.setp(textObj, text=name + '\n' + str(val)[:16])
self.redraw()
def modifZone(self, nameVar, ind):
""" modification interactive des points de la zone d'indice ind de name nameVar
"""
zone = self.listeZone[nameVar][ind]
self.polyInteract = PolygonInteractor(self, zone, nameVar, ind)
zone.set_visible(False)
self.cnv.add_line(self.polyInteract.line)
self.draw()
def finModifZone(self):
"""fonction qui met fin a la modification de la zone courante"""
if self.polyInteract != None:
self.polyInteract.set_visible(False)
self.polyInteract.disable()
# on informe la GUI des nouvelles coordonnees
var, ind = self.polyInteract.typeVariable, self.polyInteract.ind
x, y = self.polyInteract.lx, self.polyInteract.ly
#print x,y
xy = zip(x, y)
self.gui.modifBox.onModifZoneCoord(var, ind, xy)
zone = self.listeZone[var][ind]
zone.set_data(x, y)
zone.set_visible(True)
# on modifie la position du texte
txt = self.listeZoneText[var][ind]
if type(txt) == type([5, 6]):
txt[0].set_position((x[0], y[0]))
for i in range(1, len(txt)):
txt[i].set_position((x[i - 1], y[i - 1]))
else:
txt.set_position(
(mean(x) * .1 + x[0] * .9, mean(y) * .1 + y[0] * .9))
self.draw()
def setAllZones(self, dicZone):
"""updates all zones when a file is imported
"""
for var in dicZone.keys():
self.listeZone[var] = []
self.curVar = var
lz = dicZone[var]
nbz = len(lz['name'])
for i in range(nbz):
if lz['name'][i] == '': continue
coords = lz['coords'][i]
self.addZone(lz['media'][i], lz['name'][i], lz['value'][i],
coords)
self.setUnvisibleZones()
#self.redraw()
#####################################################################
# Gestion de l'interaction de la souris
# pour la creation des zones
#####################################################################
#methode executee lors d'un clic de souris dans le canvas
def mouse_clic(self, evt):
if evt.inaxes is None:
return
if self.curZone == None: # au depart
self.x1 = [float(str(evt.xdata)[:6])
] # pour aovir chiffre pas trop long
self.y1 = [float(str(evt.ydata)[:6])]
self.setcurZone(Line2D(self.x1, self.y1))
self.cnv.add_line(self.curZone)
self.m2 = self.mpl_connect('motion_notify_event',
self.mouse_motion)
if self.typeZone == "POLYV":
self.polyVdialog()
if self.typeZone == "POINT":
self.deconnecte()
self.setZoneEnd(evt)
else: # points suivants
if self.typeZone == "POLYV": # and evt.button ==1:
if evt.button == 3: self.deconnecte()
rep = self.polyVdialog() # dialog for the current value of z
if rep == False: return
self.x1.append(float(str(evt.xdata)[:6]))
self.y1.append(float(str(evt.ydata)[:6]))
if self.typeZone == "LINE" or self.typeZone == "RECT":
self.deconnecte() #fin des le 2eme point
self.setZoneEnd(evt)
if self.typeZone in ["POLY", "POLYV"
] and evt.button == 3: # fin du polygone
self.deconnecte()
self.setZoneEnd(evt)
#methode executee lors du deplacement de la souris dans le canvas suite a un mouse_clic
def mouse_motion(self, evt):
time.sleep(0.1)
if evt.inaxes is None: return
lx, ly = self.x1 * 1, self.y1 * 1
if self.typeZone == "RECT":
xr, yr = self.creeRectangle(self.x1[0], self.y1[0], evt.xdata,
evt.ydata)
self.curZone.set_data(xr, yr)
else: # autres cas
lx.append(evt.xdata)
ly.append(evt.ydata)
self.curZone.set_data(lx, ly)
self.draw()
def polyVdialog(self):
lst0 = [('Value', 'Text', 0)]
dialg = config.dialogs.genericDialog(self.gui, 'value', lst0)
values = dialg.getValues()
if values != None:
val = float(values[0])
#print val*2
self.tempZoneVal.append(val)
return True
else:
return False
def creeRectangle(self, x1, y1, x2, y2):
xr = [x1, x2, x2, x1, x1]
yr = [y1, y1, y2, y2, y1]
return [xr, yr]
def deconnecte(self):
# deconnecter la souris
self.mpl_disconnect(self.m1)
self.mpl_disconnect(self.m2)
###################################################################
# deplacer une zone ##############################
def startMoveZone(self, nameVar, ind):
""" methode qui demarre les interactions avec la souris"""
# reperer la zone et rajouter un point de couleur
self.nameVar, self.ind = nameVar, ind
zone = self.listeZone[nameVar][ind]
self.curZone = zone
self.lx, self.ly = zone.get_xdata(), zone.get_ydata()
self.xstart = self.lx[0] * 1.
self.ystart = self.ly[0] * 1.
self.ptstart = Line2D([self.xstart], [self.ystart],
marker='o',
markersize=7,
markerfacecolor='r')
self.cnv.add_line(self.ptstart)
self.m1 = self.mpl_connect('button_press_event', self.zoneM_clic)
self.draw()
def zoneM_clic(self, evt):
""" action au premier clic"""
if evt.inaxes is None: return
#if evt.button==3: self.finMoveZone(evt) # removed OA 6/2/13
d = sqrt((evt.xdata - self.xstart)**2 + (evt.ydata - self.ystart)**2)
xmn, xmx = self.xlim
ymn, ymx = self.ylim
dmax = sqrt((xmx - xmn)**2 + (ymx - ymn)**2) / 100
if d > dmax: return
self.m2 = self.mpl_connect('motion_notify_event', self.zone_motion)
self.m3 = self.mpl_connect('button_release_event', self.finMoveZone)
self.mpl_disconnect(self.m1)
def zone_motion(self, evt):
""" methode pour deplacer la zone quand on deplace la souris"""
# reperer le curseur proche du point de couleur
time.sleep(0.1)
if evt.inaxes is None: return
# changer els coord du polygone lorsque l'on deplace la souris
lx = [a + evt.xdata - self.xstart for a in self.lx]
ly = [a + evt.ydata - self.ystart for a in self.ly]
self.ptstart.set_data(lx[0], ly[0])
self.curZone.set_data(lx, ly)
self.draw()
def finMoveZone(self, evt):
""" methode pour arret de deplacement de la zone"""
# lorsque l'on relache la souris arreter les mpl connect
self.mpl_disconnect(self.m2)
self.mpl_disconnect(self.m3)
# renvoyer les nouvelels coordonnes au modele
lx, ly = self.curZone.get_xdata(), self.curZone.get_ydata()
self.listeZone[self.nameVar][self.ind].set_data(lx, ly)
xy = zip(lx, ly)
self.gui.modifBox.onModifZoneCoord(self.nameVar, self.ind, xy)
# on modifie la position du texte
txt = self.listeZoneText[self.nameVar][self.ind]
if type(txt) == type([5, 6]):
txt[0].set_position((lx[0], ly[0]))
for i in range(1, len(txt)):
txt[i].set_position(
(lx[i - 1],
ly[i - 1])) #-1 because 1st position zone names
else:
txt.set_position(
(mean(lx) * .1 + lx[0] * .9, mean(ly) * .1 + ly[0] * .9))
self.ptstart.set_visible(False)
self.ptstart = None
self.curZone = None
self.draw()
def plot_day_summary2_ohlc(ax, opens, highs, lows, closes, ticksize=4,
colorup='k', colordown='r',
):
"""Represent the time, open, high, low, close as a vertical line
ranging from low to high. The left tick is the open and the right
tick is the close.
*opens*, *highs*, *lows* and *closes* must have the same length.
NOTE: this code assumes if any value open, high, low, close is
missing (*-1*) they all are missing
Parameters
----------
ax : `Axes`
an Axes instance to plot to
opens : sequence
sequence of opening values
highs : sequence
sequence of high values
lows : sequence
sequence of low values
closes : sequence
sequence of closing values
ticksize : int
size of open and close ticks in points
colorup : color
the color of the lines where close >= open
colordown : color
the color of the lines where close < open
Returns
-------
ret : list
a list of lines added to the axes
"""
_check_input(opens, highs, lows, closes)
rangeSegments = [((i, low), (i, high)) for i, low, high in
zip(xrange(len(lows)), lows, highs) if low != -1]
# the ticks will be from ticksize to 0 in points at the origin and
# we'll translate these to the i, close location
openSegments = [((-ticksize, 0), (0, 0))]
# the ticks will be from 0 to ticksize in points at the origin and
# we'll translate these to the i, close location
closeSegments = [((0, 0), (ticksize, 0))]
offsetsOpen = [(i, open) for i, open in
zip(xrange(len(opens)), opens) if open != -1]
offsetsClose = [(i, close) for i, close in
zip(xrange(len(closes)), closes) if close != -1]
scale = ax.figure.dpi * (1.0 / 72.0)
tickTransform = Affine2D().scale(scale, 0.0)
colorup = mcolors.to_rgba(colorup)
colordown = mcolors.to_rgba(colordown)
colord = {True: colorup, False: colordown}
colors = [colord[open < close] for open, close in
zip(opens, closes) if open != -1 and close != -1]
useAA = 0, # use tuple here
lw = 1, # and here
rangeCollection = LineCollection(rangeSegments,
colors=colors,
linewidths=lw,
antialiaseds=useAA,
)
openCollection = LineCollection(openSegments,
colors=colors,
antialiaseds=useAA,
linewidths=lw,
offsets=offsetsOpen,
transOffset=ax.transData,
)
openCollection.set_transform(tickTransform)
closeCollection = LineCollection(closeSegments,
colors=colors,
antialiaseds=useAA,
linewidths=lw,
offsets=offsetsClose,
transOffset=ax.transData,
)
closeCollection.set_transform(tickTransform)
minpy, maxx = (0, len(rangeSegments))
miny = min([low for low in lows if low != -1])
maxy = max([high for high in highs if high != -1])
corners = (minpy, miny), (maxx, maxy)
ax.update_datalim(corners)
ax.autoscale_view()
# add these last
ax.add_collection(rangeCollection)
ax.add_collection(openCollection)
ax.add_collection(closeCollection)
return rangeCollection, openCollection, closeCollection
