def divideScale(self, x1, x2, maxMajorSteps, maxMinorSteps, stepSize=0.):
"""
Calculate a scale division for an interval
:param float x1: First interval limit
:param float x2: Second interval limit
:param int maxMajorSteps: Maximum for the number of major steps
:param int maxMinorSteps: Maximum number of minor steps
:param float stepSize: Step size. If stepSize == 0.0, the scaleEngine calculates one
:return: Calculated scale division
"""
interval = QwtInterval(x1, x2).normalized()
if interval.width() <= 0:
return QwtScaleDiv()
stepSize = abs(stepSize)
if stepSize == 0.:
if maxMajorSteps < 1:
maxMajorSteps = 1
stepSize = divideInterval(interval.width(), maxMajorSteps,
self.base())
scaleDiv = QwtScaleDiv()
if stepSize != 0.:
ticks = self.buildTicks(interval, stepSize, maxMinorSteps)
scaleDiv = QwtScaleDiv(interval, ticks)
if x1 > x2:
scaleDiv.invert()
return scaleDiv
def __init__(self):
self.xEnabled = True
self.yEnabled = True
self.xMinEnabled = False
self.yMinEnabled = False
self.xScaleDiv = QwtScaleDiv()
self.yScaleDiv = QwtScaleDiv()
self.majorPen = QPen()
self.minorPen = QPen()
def divideScale(self, x1, x2, maxMajorSteps, maxMinorSteps, stepSize=0.):
"""
Calculate a scale division for an interval
:param float x1: First interval limit
:param float x2: Second interval limit
:param int maxMajorSteps: Maximum for the number of major steps
:param int maxMinorSteps: Maximum number of minor steps
:param float stepSize: Step size. If stepSize == 0.0, the scaleEngine calculates one
:return: Calculated scale division
"""
interval = QwtInterval(x1, x2).normalized()
interval = interval.limited(LOG_MIN, LOG_MAX)
if interval.width() <= 0:
return QwtScaleDiv()
logBase = self.base()
if interval.maxValue()/interval.minValue() < logBase:
linearScaler = QwtLinearScaleEngine()
linearScaler.setAttributes(self.attributes())
linearScaler.setReference(self.reference())
linearScaler.setMargins(self.lowerMargin(), self.upperMargin())
if stepSize != 0.:
if stepSize < 0.:
stepSize = -np.power(logBase, -stepSize)
else:
stepSize = np.power(logBase, stepSize)
return linearScaler.divideScale(x1, x2, maxMajorSteps,
maxMinorSteps, stepSize)
stepSize = abs(stepSize)
if stepSize == 0.:
if maxMajorSteps < 1:
maxMajorSteps = 1
stepSize = self.divideInterval(
qwtLogInterval(logBase, interval).width(), maxMajorSteps)
if stepSize < 1.:
stepSize = 1.
scaleDiv = QwtScaleDiv()
if stepSize != 0.:
ticks = self.buildTicks(interval, stepSize, maxMinorSteps)
scaleDiv = QwtScaleDiv(interval, ticks)
if x1 > x2:
scaleDiv.invert()
return scaleDiv
def __init__(self):
self.spacing = 4
self.penWidth = 0
self.minExtent = 0.0
self.components = (
QwtAbstractScaleDraw.Backbone
| QwtAbstractScaleDraw.Ticks
| QwtAbstractScaleDraw.Labels
)
self.tick_length = {
QwtScaleDiv.MinorTick: 4.0,
QwtScaleDiv.MediumTick: 6.0,
QwtScaleDiv.MajorTick: 8.0,
}
self.tick_lighter_factor = {
QwtScaleDiv.MinorTick: 100,
QwtScaleDiv.MediumTick: 100,
QwtScaleDiv.MajorTick: 100,
}
self.map = QwtScaleMap()
self.scaleDiv = QwtScaleDiv()
self.labelCache = {}
def divideScale(self, x1, x2, maxMajorSteps, maxMinorSteps, stepSize=0.):
interval = QwtInterval(x1, x2).normalized()
if interval.width() <= 0:
return QwtScaleDiv()
stepSize = abs(stepSize)
if stepSize == 0.:
if maxMajorSteps < 1:
maxMajorSteps = 1
stepSize = divideInterval(interval.width(), maxMajorSteps,
self.base())
scaleDiv = QwtScaleDiv()
if stepSize != 0.:
ticks = self.buildTicks(interval, stepSize, maxMinorSteps)
scaleDiv = QwtScaleDiv(interval, ticks)
if x1 > x2:
scaleDiv.invert()
return scaleDiv
def divideScale(self, x1, x2, maxMajorSteps, maxMinorSteps, stepSize=0.0):
"""
Calculate a scale division for an interval
:param float x1: First interval limit
:param float x2: Second interval limit
:param int maxMajorSteps: Maximum for the number of major steps
:param int maxMinorSteps: Maximum number of minor steps
:param float stepSize: Step size. If stepSize == 0.0, the scaleEngine calculates one
:return: Calculated scale division
"""
interval = QwtInterval(x1, x2).normalized()
if interval.width() <= 0:
return QwtScaleDiv()
stepSize = abs(stepSize)
if stepSize == 0.0:
if maxMajorSteps < 1:
maxMajorSteps = 1
stepSize = divideInterval(interval.width(), maxMajorSteps,
self.base())
scaleDiv = QwtScaleDiv()
if stepSize != 0.0:
ticks = self.buildTicks(interval, stepSize, maxMinorSteps)
scaleDiv = QwtScaleDiv(interval, ticks)
if x1 > x2:
scaleDiv.invert()
return scaleDiv
def divideScale(self, x1, x2, maxMajorSteps, maxMinorSteps, stepSize=0.):
interval = QwtInterval(x1, x2).normalized()
interval = interval.limited(LOG_MIN, LOG_MAX)
if interval.width() <= 0:
return QwtScaleDiv()
logBase = self.base()
if interval.maxValue()/interval.minValue() < logBase:
linearScaler = QwtLinearScaleEngine()
linearScaler.setAttributes(self.attributes())
linearScaler.setReference(self.reference())
linearScaler.setMargins(self.lowerMargin(), self.upperMargin())
if stepSize != 0.:
if stepSize < 0.:
stepSize = -np.power(logBase, -stepSize)
else:
stepSize = np.power(logBase, stepSize)
return linearScaler.divideScale(x1, x2, maxMajorSteps,
maxMinorSteps, stepSize)
stepSize = abs(stepSize)
if stepSize == 0.:
if maxMajorSteps < 1:
maxMajorSteps = 1
stepSize = self.divideInterval(
qwtLogInterval(logBase, interval).width(), maxMajorSteps)
if stepSize < 1.:
stepSize = 1.
scaleDiv = QwtScaleDiv()
if stepSize != 0.:
ticks = self.buildTicks(interval, stepSize, maxMinorSteps)
scaleDiv = QwtScaleDiv(interval, ticks)
if x1 > x2:
scaleDiv.invert()
return scaleDiv
def divideScale(self, x1, x2, maxMajorSteps, maxMinorSteps, stepSize=0.):
"""
Calculate a scale division for an interval
:param float x1: First interval limit
:param float x2: Second interval limit
:param int maxMajorSteps: Maximum for the number of major steps
:param int maxMinorSteps: Maximum number of minor steps
:param float stepSize: Step size. If stepSize == 0.0, the scaleEngine calculates one
:return: Calculated scale division
"""
interval = QwtInterval(x1, x2).normalized()
interval = interval.limited(LOG_MIN, LOG_MAX)
if interval.width() <= 0:
return QwtScaleDiv()
logBase = self.base()
if interval.maxValue()/interval.minValue() < logBase:
linearScaler = QwtLinearScaleEngine()
linearScaler.setAttributes(self.attributes())
linearScaler.setReference(self.reference())
linearScaler.setMargins(self.lowerMargin(), self.upperMargin())
if stepSize != 0.:
if stepSize < 0.:
stepSize = -np.power(logBase, -stepSize)
else:
stepSize = np.power(logBase, stepSize)
return linearScaler.divideScale(x1, x2, maxMajorSteps,
maxMinorSteps, stepSize)
stepSize = abs(stepSize)
if stepSize == 0.:
if maxMajorSteps < 1:
maxMajorSteps = 1
stepSize = self.divideInterval(
qwtLogInterval(logBase, interval).width(), maxMajorSteps)
if stepSize < 1.:
stepSize = 1.
scaleDiv = QwtScaleDiv()
if stepSize != 0.:
ticks = self.buildTicks(interval, stepSize, maxMinorSteps)
scaleDiv = QwtScaleDiv(interval, ticks)
if x1 > x2:
scaleDiv.invert()
return scaleDiv
def __init__(self):
self.spacing = 4
self.penWidth = 0
self.minExtent = 0.
self.components = QwtAbstractScaleDraw.Backbone|\
QwtAbstractScaleDraw.Ticks|\
QwtAbstractScaleDraw.Labels
self.tickLength = [None] * 3
self.tickLength[QwtScaleDiv.MinorTick] = 4.0
self.tickLength[QwtScaleDiv.MediumTick] = 6.0
self.tickLength[QwtScaleDiv.MajorTick] = 8.0
self.map = QwtScaleMap()
self.scaleDiv = QwtScaleDiv()
self.labelCache = {}
def divideScale(self, x1, x2, maxMajorSteps, maxMinorSteps, stepSize=0.):
interval = QwtInterval(x1, x2).normalized()
if interval.width() <= 0:
return QwtScaleDiv()
stepSize = abs(stepSize)
if stepSize == 0.:
if maxMajorSteps < 1:
maxMajorSteps = 1
stepSize = divideInterval(interval.width(), maxMajorSteps,
self.base())
scaleDiv = QwtScaleDiv()
if stepSize != 0.:
ticks = self.buildTicks(interval, stepSize, maxMinorSteps)
scaleDiv = QwtScaleDiv(interval, ticks)
if x1 > x2:
scaleDiv.invert()
return scaleDiv
def divideScale(self, x1, x2, maxMajorSteps, maxMinorSteps, stepSize=0.):
interval = QwtInterval(x1, x2).normalized()
interval = interval.limited(LOG_MIN, LOG_MAX)
if interval.width() <= 0:
return QwtScaleDiv()
logBase = self.base()
if interval.maxValue() / interval.minValue() < logBase:
linearScaler = QwtLinearScaleEngine()
linearScaler.setAttributes(self.attributes())
linearScaler.setReference(self.reference())
linearScaler.setMargins(self.lowerMargin(), self.upperMargin())
if stepSize != 0.:
if stepSize < 0.:
stepSize = -np.power(logBase, -stepSize)
else:
stepSize = np.power(logBase, stepSize)
return linearScaler.divideScale(x1, x2, maxMajorSteps,
maxMinorSteps, stepSize)
stepSize = abs(stepSize)
if stepSize == 0.:
if maxMajorSteps < 1:
maxMajorSteps = 1
stepSize = self.divideInterval(
qwtLogInterval(logBase, interval).width(), maxMajorSteps)
if stepSize < 1.:
stepSize = 1.
scaleDiv = QwtScaleDiv()
if stepSize != 0.:
ticks = self.buildTicks(interval, stepSize, maxMinorSteps)
scaleDiv = QwtScaleDiv(interval, ticks)
if x1 > x2:
scaleDiv.invert()
return scaleDiv
