1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
|
#/*##########################################################################
# Copyright (C) 2004-2012 European Synchrotron Radiation Facility
#
# This file is part of the PyMca X-ray Fluorescence Toolkit developed at
# the ESRF by the Software group.
#
# This file is free software; you can redistribute it and/or modify it
# under the terms of the GNU Lesser General Public License as published by the Free
# Software Foundation; either version 2 of the License, or (at your option)
# any later version.
#
# This file is distributed in the hope that it will be useful, but WITHOUT ANY
# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
# details.
#
#############################################################################*/
__author__ = "V.A. Sole - ESRF Software Group"
__license__ = "LGPL"
__doc__ = """
Any plot window willing to accept 1D plugins should implement the methods
defined in this class.
The plugins will be compatible with any 1D-plot window that provides the methods:
addCurve
getActiveCurve
getAllCurves
getGraphXLimits
getGraphYLimits
getGraphTitle
getGraphXTitle
getGraphYTitle
removeCurve
setActiveCurve
setGraphTitle
setGraphXLimits
setGraphYLimits
setGraphXTitle
setGraphYTitle
On instantiation, this clase imports all the plugins found in the PyMcaPlugins
directory and stores them into the attributes pluginList and pluginInstanceDict
"""
import os
import sys
import glob
PLUGINS_DIR = None
try:
if os.path.exists(os.path.join(os.path.dirname(__file__), "PyMcaPlugins")):
from PyMca import PyMcaPlugins
PLUGINS_DIR = os.path.dirname(PyMcaPlugins.__file__)
else:
directory = os.path.dirname(__file__)
while True:
if os.path.exists(os.path.join(directory, "PyMcaPlugins")):
PLUGINS_DIR = os.path.join(directory, "PyMcaPlugins")
break
directory = os.path.dirname(directory)
if len(directory) < 5:
break
except:
pass
DEBUG = 0
class Plot1DBase(object):
def __init__(self):
self.__pluginDirList = []
self.pluginList = []
self.pluginInstanceDict = {}
self.getPlugins()
def setPluginDirectoryList(self, dirlist):
"""
:param dirlist: Set directories to search for Plot1D plugins
:type dirlist: list
"""
for directory in dirlist:
if not os.path.exists(directory):
raise IOError("Directory:\n%s\ndoes not exist." % directory)
self.__pluginDirList = dirlist
def getPluginDirectoryList(self):
"""
:return dirlist: List of directories to search for Plot1D plugins
"""
return self.__pluginDirList
def getPlugins(self):
"""
Import or reloads all the available plugins.
:return: The number of plugins loaded.
"""
if self.__pluginDirList == []:
self.__pluginDirList = [PLUGINS_DIR]
self.pluginList = []
for directory in self.__pluginDirList:
if directory is None:
continue
if not os.path.exists(directory):
raise IOError("Directory:\n%s\ndoes not exist." % directory)
fileList = glob.glob(os.path.join(directory, "*.py"))
targetMethod = 'getPlugin1DInstance'
# prevent unnecessary imports
moduleList = []
for fname in fileList:
# in Python 3, rb implies bytes and not strings
f = open(fname, 'r')
lines = f.readlines()
f.close()
f = None
for line in lines:
if line.startswith("def"):
if line.split(" ")[1].startswith(targetMethod):
moduleList.append(fname)
break
for module in moduleList:
try:
pluginName = os.path.basename(module)[:-3]
if directory == PLUGINS_DIR:
plugin = "PyMcaPlugins." + pluginName
else:
plugin = pluginName
if directory not in sys.path:
sys.path.insert(0, directory)
if pluginName in self.pluginList:
idx = self.pluginList.index(pluginName)
del self.pluginList[idx]
if plugin in self.pluginInstanceDict.keys():
del self.pluginInstanceDict[plugin]
if plugin in sys.modules:
if hasattr(sys.modules[plugin], targetMethod):
if sys.version.startswith('3.3'):
import imp
imp.reload(sys.modules[plugin])
else:
reload(sys.modules[plugin])
else:
__import__(plugin)
if hasattr(sys.modules[plugin], targetMethod):
self.pluginInstanceDict[plugin] = \
sys.modules[plugin].getPlugin1DInstance(self)
self.pluginList.append(plugin)
except:
if DEBUG:
print("Problem importing module %s" % plugin)
raise
return len(self.pluginList)
def addCurve(self, x, y, legend=None, info=None, replace=False, replot=True):
"""
Add the 1D curve given by x an y to the graph.
:param x: The data corresponding to the x axis
:type x: list or numpy.ndarray
:param y: The data corresponding to the y axis
:type y: list or numpy.ndarray
:param legend: The legend to be associated to the curve
:type legend: string or None
:param info: Dictionary of information associated to the curve
:type info: dict or None
:param replace: Flag to indicate if already existing curves are to be deleted
:type replace: boolean default False
:param replot: Flag to indicate plot is to be immediately updated
:type replot: boolean default True
"""
print("addCurve not implemented")
return None
def getActiveCurve(self, just_legend=False):
"""
:param just_legend: Flag to specify the type of output required
:type just_legend: boolean
:return: legend of the active curve or list [x, y, legend, info]
:rtype: string or list
Function to access the graph currently active curve.
It returns None in case of not having an active curve.
Default output has the form:
xvalues, yvalues, legend, dict
where dict is a dictionnary containing curve info.
For the time being, only the plot labels associated to the
curve are warranted to be present under the keys xlabel, ylabel.
If just_legend is True:
The legend of the active curve (or None) is returned.
"""
print("getActiveCurve not implemented")
return None
def getAllCurves(self, just_legend=False):
"""
:param just_legend: Flag to specify the type of output required
:type just_legend: boolean
:return: legend of the curves or list [[x, y, legend, info], ...]
:rtype: list of strings or list of curves
It returns an empty list in case of not having any curve.
If just_legend is False:
It returns a list of the form:
[[xvalues0, yvalues0, legend0, dict0],
[xvalues1, yvalues1, legend1, dict1],
[...],
[xvaluesn, yvaluesn, legendn, dictn]]
or just an empty list.
If just_legend is True:
It returns a list of the form:
[legend0, legend1, ..., legendn]
or just an empty list.
"""
print("getAllCurves not implemented")
return []
def getGraphXLimits(self):
"""
:return: Two floats with the X axis limits
Get the graph X limits.
"""
print("getGraphXLimits not implemented")
return 0.0, 100.0
def getGraphYLimits(self):
"""
Get the graph Y (left) limits.
:return: Two floats with the Y (left) axis limits
"""
print("getGraphYLimits not implemented")
return 0.0, 100.0
def getGraphTitle(self):
"""
:return: The graph title
:rtype: string
"""
print("getGraphTitle not implemented")
return "Title"
def getGraphXTitle(self):
"""
:return: The graph X axis label
:rtype: string
"""
print("getGraphXTitle not implemented")
return "X"
def getGraphYTitle(self):
"""
:return: The graph Y axis label
:rtype: string
"""
return "Y"
def setGraphXLimits(self, xmin, xmax, replot=False):
"""
Set the graph X limits.
:param xmin: minimum value of the axis
:type xmin: float
:param xmax: minimum value of the axis
:type xmax: float
:param replot: Flag to indicate plot is to be immediately updated
:type replot: boolean default False
"""
print("setGraphXLimits not implemented")
return
def setGraphYLimits(self, ymin, ymax, replot=False):
"""
Set the graph Y (left) limits.
:param ymin: minimum value of the axis
:type ymin: float
:param ymax: minimum value of the axis
:type ymax: float
:param replot: Flag to indicate plot is to be immediately updated
:type replot: boolean default False
"""
print("setGraphYLimits not implemented")
return
def removeCurve(self, legend, replot=True):
"""
Remove the curve associated to the supplied legend from the graph.
The graph will be updated if replot is true.
:param legend: The legend associated to the curve to be deleted
:type legend: string or None
:param replot: Flag to indicate plot is to be immediately updated
:type replot: boolean default True
"""
print("removeCurve not implemented")
return None
def setActiveCurve(self, legend):
"""
Funtion to request the plot window to set the curve with the specified legend
as the active curve.
:param legend: The legend associated to the curve
:type legend: string
"""
print("setActiveCurve not implemented")
return None
def setGraphTitle(self, title):
"""
:param title: The title to be set
:type title: string
"""
print("setGraphTitle not implemented")
def setGraphXTitle(self, title):
"""
:param title: The title to be associated to the X axis
:type title: string
"""
print("setGraphXTitle not implemented")
def setGraphYTitle(self, title):
"""
:param title: The title to be associated to the X axis
:type title: string
"""
print("setGraphYTitle not implemented")
|
