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
|
# -*- coding: utf-8 -*-
#
# Licensed under the terms of the Qwt License
# Copyright (c) 2002 Uwe Rathmann, for the original C++ code
# Copyright (c) 2015 Pierre Raybaut, for the Python translation/optimization
# (see LICENSE file for more details)
"""
QwtScaleDiv
-----------
.. autoclass:: QwtScaleDiv
:members:
"""
import copy
from qwt.interval import QwtInterval
class QwtScaleDiv(object):
"""
A class representing a scale division
A Qwt scale is defined by its boundaries and 3 list
for the positions of the major, medium and minor ticks.
The `upperLimit()` might be smaller than the `lowerLimit()`
to indicate inverted scales.
Scale divisions can be calculated from a `QwtScaleEngine`.
.. seealso::
:py:meth:`qwt.scale_engine.QwtScaleEngine.divideScale()`,
:py:meth:`qwt.plot.QwtPlot.setAxisScaleDiv()`
Scale tick types:
* `QwtScaleDiv.NoTick`: No ticks
* `QwtScaleDiv.MinorTick`: Minor ticks
* `QwtScaleDiv.MediumTick`: Medium ticks
* `QwtScaleDiv.MajorTick`: Major ticks
* `QwtScaleDiv.NTickTypes`: Number of valid tick types
.. py:class:: QwtScaleDiv()
Basic constructor. Lower bound = Upper bound = 0.
.. py:class:: QwtScaleDiv(interval, ticks)
:noindex:
:param qwt.interval.QwtInterval interval: Interval
:param list ticks: list of major, medium and minor ticks
.. py:class:: QwtScaleDiv(lowerBound, upperBound)
:noindex:
:param float lowerBound: First boundary
:param float upperBound: Second boundary
.. py:class:: QwtScaleDiv(lowerBound, upperBound, ticks)
:noindex:
:param float lowerBound: First boundary
:param float upperBound: Second boundary
:param list ticks: list of major, medium and minor ticks
.. py:class:: QwtScaleDiv(lowerBound, upperBound, minorTicks, mediumTicks, majorTicks)
:noindex:
:param float lowerBound: First boundary
:param float upperBound: Second boundary
:param list minorTicks: list of minor ticks
:param list mediumTicks: list of medium ticks
:param list majorTicks: list of major ticks
.. note::
lowerBound might be greater than upperBound for inverted scales
"""
# enum TickType
NoTick = -1
MinorTick, MediumTick, MajorTick, NTickTypes = list(range(4))
def __init__(self, *args):
self.__ticks = None
if len(args) == 2 and isinstance(args[1], (tuple, list)):
interval, ticks = args
self.__lowerBound = interval.minValue()
self.__upperBound = interval.maxValue()
self.__ticks = ticks[:]
elif len(args) == 2:
self.__lowerBound, self.__upperBound = args
elif len(args) == 3:
self.__lowerBound, self.__upperBound, ticks = args
self.__ticks = ticks[:]
elif len(args) == 5:
(
self.__lowerBound,
self.__upperBound,
minorTicks,
mediumTicks,
majorTicks,
) = args
self.__ticks = [0] * self.NTickTypes
self.__ticks[self.MinorTick] = minorTicks
self.__ticks[self.MediumTick] = mediumTicks
self.__ticks[self.MajorTick] = majorTicks
elif len(args) == 0:
self.__lowerBound, self.__upperBound = 0.0, 0.0
else:
raise TypeError(
"%s() takes 0, 2, 3 or 5 argument(s) (%s given)"
% (self.__class__.__name__, len(args))
)
def setInterval(self, *args):
"""
Change the interval
.. py:method:: setInterval(lowerBound, upperBound)
:noindex:
:param float lowerBound: First boundary
:param float upperBound: Second boundary
.. py:method:: setInterval(interval)
:noindex:
:param qwt.interval.QwtInterval interval: Interval
.. note::
lowerBound might be greater than upperBound for inverted scales
"""
if len(args) == 2:
self.__lowerBound, self.__upperBound = args
elif len(args) == 1:
(interval,) = args
self.__lowerBound = interval.minValue()
self.__upperBound = interval.maxValue()
else:
raise TypeError(
"%s().setInterval() takes 1 or 2 argument(s) (%s "
"given)" % (self.__class__.__name__, len(args))
)
def interval(self):
"""
:return: Interval
"""
return QwtInterval(self.__lowerBound, self.__upperBound)
def setLowerBound(self, lowerBound):
"""
Set the first boundary
:param float lowerBound: First boundary
.. seealso::
:py:meth:`lowerBound()`, :py:meth:`setUpperBound()`
"""
self.__lowerBound = lowerBound
def lowerBound(self):
"""
:return: the first boundary
.. seealso::
:py:meth:`upperBound()`
"""
return self.__lowerBound
def setUpperBound(self, upperBound):
"""
Set the second boundary
:param float lowerBound: Second boundary
.. seealso::
:py:meth:`upperBound()`, :py:meth:`setLowerBound()`
"""
self.__upperBound = upperBound
def upperBound(self):
"""
:return: the second boundary
.. seealso::
:py:meth:`lowerBound()`
"""
return self.__upperBound
def range(self):
"""
:return: upperBound() - lowerBound()
"""
return self.__upperBound - self.__lowerBound
def __eq__(self, other):
if self.__ticks is None:
return False
if (
self.__lowerBound != other.__lowerBound
or self.__upperBound != other.__upperBound
):
return False
return self.__ticks == other.__ticks
def __ne__(self, other):
return not self.__eq__(other)
def isEmpty(self):
"""
Check if the scale division is empty( lowerBound() == upperBound() )
"""
return self.__lowerBound == self.__upperBound
def isIncreasing(self):
"""
Check if the scale division is increasing( lowerBound() <= upperBound() )
"""
return self.__lowerBound <= self.__upperBound
def contains(self, value):
"""
Return if a value is between lowerBound() and upperBound()
:param float value: Value
:return: True/False
"""
min_ = min([self.__lowerBound, self.__upperBound])
max_ = max([self.__lowerBound, self.__upperBound])
return value >= min_ and value <= max_
def invert(self):
"""
Invert the scale division
.. seealso::
:py:meth:`inverted()`
"""
(self.__lowerBound, self.__upperBound) = self.__upperBound, self.__lowerBound
for index in range(self.NTickTypes):
self.__ticks[index].reverse()
def inverted(self):
"""
:return: A scale division with inverted boundaries and ticks
.. seealso::
:py:meth:`invert()`
"""
other = copy.deepcopy(self)
other.invert()
return other
def bounded(self, lowerBound, upperBound):
"""
Return a scale division with an interval [lowerBound, upperBound]
where all ticks outside this interval are removed
:param float lowerBound: First boundary
:param float lowerBound: Second boundary
:return: Scale division with all ticks inside of the given interval
.. note::
lowerBound might be greater than upperBound for inverted scales
"""
min_ = min([self.__lowerBound, self.__upperBound])
max_ = max([self.__lowerBound, self.__upperBound])
sd = QwtScaleDiv()
sd.setInterval(lowerBound, upperBound)
for tickType in range(self.NTickTypes):
sd.setTicks(
tickType,
[
tick
for tick in self.__ticks[tickType]
if tick >= min_ and tick <= max_
],
)
return sd
def setTicks(self, tickType, ticks):
"""
Assign ticks
:param int type: MinorTick, MediumTick or MajorTick
:param list ticks: Values of the tick positions
"""
if tickType in range(self.NTickTypes):
self.__ticks[tickType] = ticks
def ticks(self, tickType):
"""
Return a list of ticks
:param int type: MinorTick, MediumTick or MajorTick
:return: Tick list
"""
if self.__ticks is not None and tickType in range(self.NTickTypes):
return self.__ticks[tickType]
else:
return []
|
