"""Container to hold plot objects."""

def __init__(self, objects):

self.objects = objects

# ----

def __additem__(self, obj):

self.objects.append(obj)

# ----

def __delitem__(self, index):

del self.objects[index]

# ----

def __setitem__(self, index, obj):

self.objects[index] = obj

# ----

def __getitem__(self, index):

return self.objects[index]

# ----

def __len__(self):

return len(self.objects)

# ----

def getBoundingBox(self, minX=None, maxX=None, absolute=False):

"""Get bounding box coverring all visible objects."""

# init values if no data in objects

rect = [numpy.array([0, 0]), numpy.array([1, 1])]

# get bouding boxes from objects

have = False

for obj in self.objects:

if obj.properties['visible']:

oRect = obj.getBoundingBox(minX, maxX, absolute)

if not oRect or not numpy.all(numpy.isfinite(oRect)):

continue

elif have and oRect:

rect[0] = numpy.minimum(rect[0], oRect[0])

rect[1] = numpy.maximum(rect[1], oRect[1])

elif oRect:

rect = oRect

have = True

# check scale

if rect[0][0] == rect[1][0]:

rect[0][0] -= 0.5

rect[1][0] += 0.5

if rect[0][1] == rect[1][1]:

rect[1][1] += 0.5

return rect

# ----

def getLegend(self):

"""Get a list of legend names."""

# get names

names = []

for obj in self.objects:

if obj.properties['visible']:

legend = obj.getLegend()

if legend and legend[0] != '':

names.append(obj.getLegend())

return names

# ----

def getPoint(self, obj, xPos, coord='screen'):

"""Get interpolated Y position for given X."""

return self.objects[obj].getPoint(xPos, coord)

# ----

def countGels(self):

"""Get number of visible gels."""

count = 0

for obj in self.objects:

if obj.properties['visible'] and obj.properties['showInGel']:

count += 1

return max(count,1)

# ----

def cropPoints(self, minX, maxX):

"""Crop points in all visible objects to selected X range."""

for obj in self.objects:

if obj.properties['visible']:

obj.cropPoints(minX, maxX)

# ----

def scaleAndShift(self, scale, shift):

"""Scale and shift all visible objects."""

for obj in self.objects:

if obj.properties['visible']:

obj.scaleAndShift(scale, shift)

# ----

def filterPoints(self, filterSize):

"""Filter points in all visible objects."""

for obj in self.objects:

if obj.properties['visible']:

obj.filterPoints(filterSize)

# ----

def draw(self, dc, printerScale, overlapLabels, reverse):

"""Draw all visible objects."""

# draw in reverse order

if reverse:

self.objects.reverse()

# draw objects

for obj in self.objects:

if obj.properties['visible']:

obj.draw(dc, printerScale)

# draw object's labels

self.drawLabels(dc, printerScale, overlapLabels)

# reverse back order

if reverse:

self.objects.reverse()

# ----

def drawLabels(self, dc, printerScale, overlapLabels):

"""Draw labels for all visible objects."""

# get labels from objects

annots = []

labels = []

for obj in self.objects:

if obj.properties['visible'] and isinstance(obj, annotations):

annots += obj.makeLabels(dc, printerScale)

elif obj.properties['visible']:

labels += obj.makeLabels(dc, printerScale)

# check labels

if not annots and not labels:

return

# sort labels

annots.sort()

annots.reverse()

labels.sort()

labels.reverse()

labels = annots + labels

# preset font by first label

font = labels[0][3]['labelFont']

colour = labels[0][3]['labelColour']

bgr = labels[0][3]['labelBgr']

bgrColour = labels[0][3]['labelBgrColour']

dc.SetFont(_scaleFont(font, printerScale['fonts']))

dc.SetTextForeground(colour)

dc.SetTextBackground(bgrColour)

if bgr:

dc.SetBackgroundMode(wx.SOLID)

# draw labels

occupied = []

for label in labels:

text = label[1]

textCoords = label[2]

properties = label[3]

# check limits

if abs(textCoords[1]) > 10000000:

continue

# check free space and draw label

if overlapLabels or self._checkFreeSpace(textCoords, occupied):

# check pen

if properties['labelFont'] != font:

font = properties['labelFont']

dc.SetFont(_scaleFont(font, printerScale['fonts']))

if properties['labelColour'] != colour:

colour = properties['labelColour']

dc.SetTextForeground(colour)

#if properties['labelBgrColour'] != bgrColour:

# bgrColour = properties['labelBgrColour']

# dc.SetTextBackground(bgrColour)

if properties['labelBgr'] != bgr:

bgr = properties['labelBgr']

if bgr:

dc.SetBackgroundMode(wx.SOLID)

else:

dc.SetBackgroundMode(wx.TRANSPARENT)

# set angle

angle = properties['labelAngle']

if angle == 90 and properties['flipped']:

angle = -90

# draw label

dc.DrawRotatedText(text, textCoords[0], textCoords[1], angle)

occupied.append(textCoords)

dc.SetBackgroundMode(wx.TRANSPARENT)

# ----

def drawGel(self, dc, gelCoords, gelHeight, printerScale):

"""Draw gel for all allowed objects."""

# draw objects

for obj in self.objects:

if obj.properties['visible'] and obj.properties['showInGel']:

obj.drawGel(dc, gelCoords, gelHeight, printerScale)

gelCoords[0] += gelHeight

# ----

def append(self, obj):

self.objects.append(obj)

# ----

def empty(self):

del self.objects[:]

# ----

def _checkFreeSpace(self, coords, occupied):

"""Check free space for label."""

curX1, curY1, curX2, curY2 = coords

# check occupied space

for occX1, occY1, occX2, occY2 in occupied:

if (curX1 < curX2) and ((occX1 <= curX1 <= occX2) or (occX1 <= curX2 <= occX2) or (curX1 <= occX1 and curX2 >= occX2)):

if (occY2 <= curY1 <= occY1) or (occY2 <= curY2 <= occY1) or (curY1 >= occY1 and curY2 <= occY2):

return False

elif (curX1 > curX2) and ((occX2 <= curX1 <= occX1) or (occX2 <= curX2 <= occX1) or (curX1 <= occX2 and curX2 >= occX1)):

if (occY1 <= curY1 <= occY2) or (occY1 <= curY2 <= occY2) or (curY1 >= occY2 and curY2 <= occY1):

return False

return True

"""Base class for annotations drawing."""

def __init__(self, points, **attr):

# set default params

self.properties = {

'visible': True,

'flipped': False,

'xOffset': 0,

'yOffset': 0,

'normalized': False,

'showInGel': False,

'exactFit': False,

'showPoints': True,

'showLabels': True,

'showXPos': True,

'pointColour': (0, 0, 255),

'pointSize': 3,

'labelAngle': 90,

'labelBgr': True,

'labelColour': (0, 0, 0),

'labelBgrColour': (255, 255, 255),

'labelFont': wx.Font(10, wx.SWISS, wx.FONTSTYLE_NORMAL, wx.FONTWEIGHT_NORMAL, 0),

'labelMaxLength': 20,

'xPosDigits': 2,

}

self.currentScale = (1., 1.)

self.currentShift = (0., 0.)

self.normalization = 1.0

# get new attributes

for name, value in attr.items():

self.properties[name] = value

# convert points to array

self.points = numpy.array([[p[0], p[1]] for p in points])

self.pointsCropped = self.points

self.pointsScaled = self.pointsCropped

if len(self.points):

self.pointsBox = (numpy.minimum.reduce(self.points), numpy.maximum.reduce(self.points))

# get labels

self.labels = ['']*len(points)

for x, point in enumerate(points):

if len(point) > 2:

self.labels[x] = point[2]

self.labelsCropped = self.labels

# calculate normalization

self._normalization()

# ----

def setProperties(self, **attr):

"""Set object properties."""

for name, value in attr.items():

self.properties[name] = value

# ----

def setNormalization(self, value):

"""Force specified normalization to be used insted of calculated one."""

value = float(value)

if value == 0.0:

value = 1.0

self.normalization = value

# ----

def getBoundingBox(self, minX=None, maxX=None, absolute=False):

"""Get bounding box for whole data or X selection"""

# use relevant data

if minX != None and maxX != None:

self.cropPoints(minX, maxX)

data = self.pointsCropped

else:

data = self.points

# check data

if not len(data):

return False

# get range

if minX != None and maxX != None:

minXY = numpy.minimum.reduce(data)

maxXY = numpy.maximum.reduce(data)

else:

minXY = [self.pointsBox[0][0], self.pointsBox[0][1]]

maxXY = [self.pointsBox[1][0], self.pointsBox[1][1]]

# extend values slightly to fit data

if not absolute and not self.properties['exactFit']:

xExtend = (maxXY[0] - minXY[0]) * 0.05

yExtend = (maxXY[1] - minXY[1]) * 0.05

minXY[0] -= xExtend

maxXY[0] += xExtend

minXY[1] -= yExtend

maxXY[1] += yExtend

# extend values to fit labels

elif not absolute:

if self.properties['showLabels'] and self.properties['labelAngle']==0:

maxXY[1] += (maxXY[1] - minXY[1]) * 0.2

elif self.properties['showLabels'] and self.properties['labelAngle']==90:

maxXY[1] += (maxXY[1] - minXY[1]) * 0.4

else:

maxXY[1] += (maxXY[1] - minXY[1]) * 0.05

# apply normalization

if self.properties['normalized']:

minXY[1] = minXY[1] / self.normalization

maxXY[1] = maxXY[1] / self.normalization

# apply offset

minXY[0] += self.properties['xOffset']

minXY[1] += self.properties['yOffset']

maxXY[0] += self.properties['xOffset']

maxXY[1] += self.properties['yOffset']

# apply flipping

if self.properties['flipped']:

minY = -1 * maxXY[1]

maxY = -1 * minXY[1]

minXY[1] = minY

maxXY[1] = maxY

return [minXY, maxXY]

# ----

def getLegend(self):

"""Get legend."""

return None

# ----

def cropPoints(self, minX, maxX):

"""Crop points to selected X range."""

# apply offset

minX -= self.properties['xOffset']

maxX -= self.properties['xOffset']

# get indexes of points in selection

i1 = mod_signal.locate(self.points, minX)

i2 = mod_signal.locate(self.points, maxX)

# crop data

self.pointsCropped = self.points[i1:i2]

self.labelsCropped = self.labels[i1:i2]

# ----

def scaleAndShift(self, scale, shift):

"""Scale and shift points to screen coordinations."""

self.pointsScaled = self.pointsCropped

xScale = scale[0]

yScale = scale[1]

xShift = shift[0]

yShift = shift[1]

# apply flipping

if self.properties['flipped']:

yScale *= -1

# apply normalization

if self.properties['normalized']:

yScale /= self.normalization

# apply offset

xShift += self.properties['xOffset'] * xScale

yShift += self.properties['yOffset'] * yScale

# recalculate data

self.pointsScaled = _scaleAndShift(self.pointsCropped, xScale, yScale, xShift, yShift)

self.currentScale = scale

self.currentShift = shift

# ----

def filterPoints(self, filterSize):

"""Filter points for printing and exporting"""

pass

# ----

def draw(self, dc, printerScale):

"""Draw object."""

# check data

if not len(self.pointsScaled):

return

# draw points

if self.properties['showPoints']:

pencolour = [max(x-70,0) for x in self.properties['pointColour']]

pen = wx.Pen(pencolour, 1*printerScale['drawings'], wx.SOLID)

brush = wx.Brush(self.properties['pointColour'], wx.SOLID)

dc.SetPen(pen)

dc.SetBrush(brush)

for point in self.pointsScaled:

dc.DrawCircle(point[0], point[1], self.properties['pointSize']*printerScale['drawings'])

# ----

def drawGel(self, dc, gelCoords, gelHeight, printerScale):

"""Draw gel."""

pass

# ----

def makeLabels(self, dc, printerScale):

"""Get object labels."""

# check labels

if not self.properties['showLabels'] or not self.labelsCropped:

return []

# set font

dc.SetFont(_scaleFont(self.properties['labelFont'], printerScale['fonts']))

# prepare labels

labels = []

format = '%0.'+`self.properties['xPosDigits']`+'f - '

for x, label in enumerate(self.labelsCropped):

# check max length

if len(label) > self.properties['labelMaxLength']:

label = label[:self.properties['labelMaxLength']] + '...'

# add X position

if self.properties['showXPos']:

label = (format % self.pointsCropped[x][0]) + label

# get position

xPos = self.pointsScaled[x][0]

yPos = self.pointsScaled[x][1]

# get text position

textSize = dc.GetTextExtent(label)

if self.properties['labelAngle'] == 90:

if self.properties['flipped']:

textXPos = xPos + textSize[1]*0.5

textYPos = yPos + 5*printerScale['drawings']

textCoords = (textXPos, textYPos, textXPos-textSize[1], textYPos+textSize[0])

else:

textXPos = xPos - textSize[1]*0.5

textYPos = yPos - 5*printerScale['drawings']

textCoords = (textXPos, textYPos, textXPos+textSize[1], textYPos-textSize[0])

elif self.properties['labelAngle'] == 0:

if self.properties['flipped']:

textXPos = xPos - textSize[0]*0.5

textYPos = yPos + 4*printerScale['drawings']

textCoords = (textXPos, textYPos, textXPos+textSize[0], textYPos-textSize[1])

else:

textXPos = xPos - textSize[0]*0.5

textYPos = yPos - textSize[1] - 4*printerScale['drawings']

textCoords = (textXPos, textYPos, textXPos+textSize[0], textYPos-textSize[1])

# add label and sort by intensity

labels.append((self.pointsCropped[x][1], label, textCoords, self.properties))

return labels

# ----

def _normalization(self):

"""Calculate normalization constants."""

normalization = 1.0

# calc normalization

if len(self.points):

normalization = self.pointsBox[1][1] / 100.

# check value

if normalization == 0.0:

normalization = 1.0

# set value

self.normalization = normalization

"""Base class for polypoints and polylines drawing."""

def __init__(self, points, **attr):

# set default params

self.properties = {

'legend': '',

'visible': True,

'flipped': False,

'xOffset': 0,

'yOffset': 0,

'normalized': False,

'showInGel': False,

'exactFit': False,

'showPoints': True,

'pointColour': (0, 0, 255),

'pointSize': 3,

'fillPoints': True,

'showLines': True,

'lineColour': (0, 0, 255),

'lineWidth': 1,

'lineStyle': wx.SOLID,

'xOffsetDigits': 2,

'yOffsetDigits': 0,

}

self.currentScale = (1., 1.)

self.currentShift = (0., 0.)

self.normalization = 1.0

# get new attributes

for name, value in attr.items():

self.properties[name] = value

# convert points to array

self.points = numpy.array(points)

self.cropped = self.points

self.scaled = self.cropped

if len(self.points):

self.pointsBox = (numpy.minimum.reduce(self.points), numpy.maximum.reduce(self.points))

# calculate normalization

self._normalization()

# ----

def setProperties(self, **attr):

"""Set object properties."""

for name, value in attr.items():

self.properties[name] = value

# ----

def setNormalization(self, value):

"""Force specified normalization to be used insted of calculated one."""

value = float(value)

if value == 0.0:

value = 1.0

self.normalization = value

# ----

def getBoundingBox(self, minX=None, maxX=None, absolute=False):

"""Get bounding box for whole data or X selection"""

# use relevant data

if minX != None and maxX != None:

self.cropPoints(minX, maxX)

data = self.cropped

else:

data = self.points

# check data

if not len(data):

return False

# get range

if minX != None and maxX != None:

minXY = numpy.minimum.reduce(data)

maxXY = numpy.maximum.reduce(data)

else:

minXY = [self.pointsBox[0][0], self.pointsBox[0][1]]

maxXY = [self.pointsBox[1][0], self.pointsBox[1][1]]

# extend values slightly to fit data

if not absolute and not self.properties['exactFit']:

xExtend = (maxXY[0] - minXY[0]) * 0.05

yExtend = (maxXY[1] - minXY[1]) * 0.05

minXY[0] -= xExtend

maxXY[0] += xExtend

minXY[1] -= yExtend

maxXY[1] += yExtend

# apply normalization

if self.properties['normalized']:

minXY[1] = minXY[1] / self.normalization

maxXY[1] = maxXY[1] / self.normalization

# apply offset

minXY[0] += self.properties['xOffset']

minXY[1] += self.properties['yOffset']

maxXY[0] += self.properties['xOffset']

maxXY[1] += self.properties['yOffset']

# apply flipping

if self.properties['flipped']:

minY = -1 * maxXY[1]

maxY = -1 * minXY[1]

minXY[1] = minY

maxXY[1] = maxY

return [minXY, maxXY]

# ----

def getLegend(self):

"""Get legend."""

# get legend

legend = self.properties['legend']

offset = ''

# add current offset

if not self.properties['normalized']:

if self.properties['xOffset']:

format = ' X%0.'+`self.properties['xOffsetDigits']`+'f'

offset += format % self.properties['xOffset']

if self.properties['yOffset']:

format = ' Y%0.'+`self.properties['yOffsetDigits']`+'f'

offset += format % self.properties['yOffset']

if legend and offset:

legend += ' (Offset%s)' % offset

# set colour

if self.properties['showPoints']:

return (legend, self.properties['pointColour'])

else:

return (legend, self.properties['lineColour'])

# ----

def cropPoints(self, minX, maxX):

"""Crop points to selected X range."""

# apply offset

minX -= self.properties['xOffset']

maxX -= self.properties['xOffset']

# crop line

if self.properties['showLines']:

self.cropped = mod_signal.crop(self.points, minX, maxX)

# crop points

else:

i1 = mod_signal.locate(self.points, minX)

i2 = mod_signal.locate(self.points, maxX)

self.cropped = self.points[i1:i2]

# ----

def scaleAndShift(self, scale, shift):

"""Scale and shift points to screen coordinations."""

self.scaled = self.cropped

xScale = scale[0]

yScale = scale[1]

xShift = shift[0]

yShift = shift[1]

# apply flipping

if self.properties['flipped']:

yScale *= -1

# apply normalization

if self.properties['normalized']:

yScale /= self.normalization

# apply offset

xShift += self.properties['xOffset'] * xScale

yShift += self.properties['yOffset'] * yScale

# recalculate data

if len(self.cropped):

self.scaled = _scaleAndShift(self.cropped, xScale, yScale, xShift, yShift)

self.currentScale = scale

self.currentShift = shift

# ----

def filterPoints(self, filterSize):

"""Filter points for printing and exporting"""

# filter data

if len(self.scaled) and self.properties['showLines']:

self.scaled = _filterPoints(self.scaled, filterSize)

# ----

def draw(self, dc, printerScale):

"""Draw object."""

# check data

if not len(self.scaled):

return

# draw lines

if self.properties['showLines'] and len(self.scaled) > 1:

pen = wx.Pen(self.properties['lineColour'], self.properties['lineWidth']*printerScale['drawings'], self.properties['lineStyle'])

brush = wx.Brush(self.properties['lineColour'], wx.SOLID)

dc.SetPen(pen)

dc.SetBrush(brush)

dc.DrawLines(self.scaled)

# draw points

if self.properties['showPoints']:

if self.properties['fillPoints']:

pencolour = [max(x-70,0) for x in self.properties['pointColour']]

pen = wx.Pen(pencolour, self.properties['lineWidth']*printerScale['drawings'], wx.SOLID)

brush = wx.Brush(self.properties['pointColour'], wx.SOLID)

else:

pencolour = self.properties['pointColour']

pen = wx.Pen(pencolour, self.properties['lineWidth']*printerScale['drawings'], wx.SOLID)

brush = wx.TRANSPARENT_BRUSH

dc.SetPen(pen)

dc.SetBrush(brush)

for point in self.scaled:

dc.DrawCircle(point[0], point[1], self.properties['pointSize']*printerScale['drawings'])

# ----

def drawGel(self, dc, gelCoords, gelHeight, printerScale):

"""Draw gel."""

pass

# ----

def makeLabels(self, dc, printerScale):

"""Get object labels."""

return []

# ----

def _normalization(self):

"""Calculate normalization constants."""

normalization = 1.0

# calc normalization

if len(self.points):

normalization = self.pointsBox[1][1] / 100.

# check value

if normalization == 0.0:

normalization = 1.0

# set value

self.normalization = normalization

"""Base class for spectrum drawing."""

def __init__(self, scan, **attr):

# set default params

self.properties = {

'legend': '',

'visible': True,

'flipped': False,

'xOffset': 0,

'yOffset': 0,

'normalized': False,

'showInGel': True,

'showSpectrum': True,

'showPoints': True,

'showLabels': True,

'showIsotopicLabels': True,

'showTicks': True,

'showGelLegend': True,

'spectrumColour': (0, 0, 255),

'spectrumWidth': 1,

'spectrumStyle': wx.SOLID,

'labelAngle': 90,

'labelDigits': 2,

'labelCharge': False,

'labelGroup': False,

'labelBgr': True,

'labelColour': (0, 0, 0),

'labelBgrColour': (255, 255, 255),

'labelFont': wx.Font(10, wx.SWISS, wx.FONTSTYLE_NORMAL, wx.FONTWEIGHT_NORMAL, 0),

'tickColour': (200, 200, 200),

'isotopeColour': None,

'msmsColour': None,

'tickWidth': 1,

'tickStyle': wx.SOLID,

'xOffsetDigits': 2,

'yOffsetDigits': 0,

}

self.currentScale = (1., 1.)

self.currentShift = (0., 0.)

self.normalization = 1.0

# get new attributes

for name, value in attr.items():

self.properties[name] = value

# convert spectrum points to array

self.spectrumPoints = numpy.array(scan.profile)

self.spectrumCropped = self.spectrumPoints

self.spectrumScaled = self.spectrumCropped

if len(self.spectrumPoints):

self.spectrumBox = (numpy.minimum.reduce(self.spectrumPoints), numpy.maximum.reduce(self.spectrumPoints))

# convert peaklist points to array

self.peaklist = copy.deepcopy(scan.peaklist)

self.peaklistPoints = numpy.array([[peak.mz, peak.ai, peak.base] for peak in scan.peaklist])

self.peaklistCropped = self.peaklistPoints

self.peaklistScaled = self.peaklistCropped

self.peaklistCroppedPeaks = self.peaklist[:]

if len(self.peaklistPoints):

self.peaklistBox = (numpy.minimum.reduce(self.peaklistPoints), numpy.maximum.reduce(self.peaklistPoints))

# calculate normalization

self._normalization()

# ----

def setProperties(self, **attr):

"""Set object properties."""

for name, value in attr.items():

self.properties[name] = value

# ----

def setNormalization(self, value):

"""Force specified normalization to be used insted of calculated one."""

value = float(value)

if value == 0.0:

value = 1.0

self.normalization = value

# ----

def getBoundingBox(self, minX=None, maxX=None, absolute=False):

"""Get bounding box for whole data or X selection."""

spectrumBox = None

peaklistBox = None

# use relevant data

if minX != None and maxX != None:

self.cropPoints(minX, maxX)

spectrumData = self.spectrumCropped

peaklistData = self.peaklistCropped

else:

spectrumData = self.spectrumPoints

peaklistData = self.peaklistPoints

# calculate bounding box for spectrum

if len(spectrumData) and self.properties['showSpectrum']:

if minX != None and maxX != None:

minXY = numpy.minimum.reduce(spectrumData)

maxXY = numpy.maximum.reduce(spectrumData)

else:

minXY = [self.spectrumBox[0][0], self.spectrumBox[0][1]]

maxXY = [self.spectrumBox[1][0], self.spectrumBox[1][1]]

if not absolute:

maxXY[1] += (maxXY[1] - minXY[1]) * 0.05

spectrumBox = [minXY, maxXY]

# calculate bounding box for peaklist

if len(peaklistData) and (self.properties['showSpectrum'] or self.properties['showLabels'] or self.properties['showTicks']):

if minX != None and maxX != None:

minXY = numpy.minimum.reduce(peaklistData)

maxXY = numpy.maximum.reduce(peaklistData)

else:

minXY = [self.peaklistBox[0][0], self.peaklistBox[0][1], self.peaklistBox[0][2]]

maxXY = [self.peaklistBox[1][0], self.peaklistBox[1][1], self.peaklistBox[1][2]]

minXY = [minXY[0], min(minXY[1:])]

maxXY = [maxXY[0], max(maxXY[1:])]

# extend values to fit labels

if not absolute:

xExtend = (maxXY[0] - minXY[0]) * 0.02

minXY[0] -= xExtend

maxXY[0] += xExtend