# -------------------------------------------------------------------------
#     Copyright (C) 2005-2012 Martin Strohalm <www.mmass.org>

#     This program is free software; you can redistribute it and/or modify
#     it under the terms of the GNU General Public License as published by
#     the Free Software Foundation; either version 3 of the License, or
#     (at your option) any later version.

#     This program 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 General Public License for more details.

#     Complete text of GNU GPL can be found in the file LICENSE.TXT in the
#     main directory of the program.
# -------------------------------------------------------------------------

# load libs
import wx
import numpy
import copy

# load modules
import mod_signal
import calculations


# MAIN PLOT OBJECTS
# -----------------

class container:
    """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 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
    # ----
    


class annotations:
    """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."""
        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."""
        
        self.normalization = 1.0
        
        # check data
        if not len(self.points):
            return
        
        # get range
        minXY, maxXY = self.pointsBox
        
        # set normalization
        self.normalization = maxXY[1] / 100.
    # ----
    


class points:
    """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,
                            '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."""
        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']:
            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)
            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."""
        
        self.normalization = 1.0
        
        # check data
        if not len(self.points):
            return
        
        # get range
        minXY, maxXY = self.pointsBox
        
        # set normalization
        self.normalization = maxXY[1] / 100.
    # ----
    


class spectrum:
    """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."""
        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
                
                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
            
            peaklistBox = [minXY, maxXY]
        
        # use both
        if spectrumBox and peaklistBox:
            minXY, maxXY = [numpy.minimum(spectrumBox[0], peaklistBox[0]), numpy.maximum(spectrumBox[1], peaklistBox[1])]
        elif spectrumBox:
            minXY, maxXY = spectrumBox
        elif peaklistBox:
            minXY, maxXY = peaklistBox
        else:
            return False
        
        # apply normalization
        if self.properties['normalized']:
            minXY[1] = minXY[1] / self.normalization
            maxXY[1] = maxXY[1] / self.normalization
        
        # apply offset
        if not self.properties['normalized']:
            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 len(self.spectrumPoints) and self.properties['showSpectrum']:
            return (legend, self.properties['spectrumColour'])
        else:
            return (legend, self.properties['tickColour'])
    # ----
    
    
    def getPoint(self, xPos, coord='screen'):
        """Get interpolated Y position for given X."""
        
        # get relevant data
        if coord == 'user':
            points = self.spectrumCropped
        else:
            points = self.spectrumScaled
        
        # check data
        if not len(points):
            return None
        
        # get xPos index
        index = mod_signal.locate(points, xPos)
        if index == 0 or index == len(points):
            return None
        
        # get yPos
        yPos = mod_signal.interpolate(points[index-1], points[index], x=xPos)
        
        return [xPos, yPos]
    # ----
    
    
    def cropPoints(self, minX, maxX):
        """Crop points to selected X range."""
        
        # apply offset
        minX -= self.properties['xOffset']
        maxX -= self.properties['xOffset']
        
        # crop spectrum data
        if self.properties['showSpectrum']:
            self.spectrumCropped = mod_signal.crop(self.spectrumPoints, minX, maxX)
        
        # crop peaklist data
        if self.properties['showSpectrum'] or self.properties['showLabels'] or self.properties['showTicks']:
            i1 = mod_signal.locate(self.peaklistPoints, minX)
            i2 = mod_signal.locate(self.peaklistPoints, maxX)
            self.peaklistCropped = self.peaklistPoints[i1:i2]
            self.peaklistCroppedPeaks = self.peaklist[i1:i2]
    # ----
    
    
    def scaleAndShift(self, scale, shift):
        """Scale and shift points to screen coordinations."""
        
        self.spectrumScaled = self.spectrumCropped
        self.peaklistScaled = self.peaklistCropped
        
        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
        if not self.properties['normalized']:
            xShift += self.properties['xOffset'] * xScale
            yShift += self.properties['yOffset'] * yScale
        
        # scale and shift spectrum data
        if len(self.spectrumCropped):
            self.spectrumScaled = _scaleAndShift(self.spectrumCropped, xScale, yScale, xShift, yShift)
        
        # scale and shift peaklist data
        if len(self.peaklistCropped):
            self.peaklistScaled = numpy.array((xScale, yScale, yScale)) * self.peaklistCropped + numpy.array((xShift, yShift, yShift))
        
        self.currentScale = scale
        self.currentShift = shift
    # ----
    
    
    def filterPoints(self, filterSize):
        """Filter spectrum points invisible in current resolution."""
        
        # filter spectrum data
        if len(self.spectrumScaled) and self.properties['showSpectrum']:
            self.spectrumScaled = _filterPoints(self.spectrumScaled, filterSize)
    # ----
    
    
    def draw(self, dc, printerScale):
        """Draw object."""
        
        # draw line spectrum
        if len(self.spectrumScaled) > 2 and self.properties['showSpectrum']:
            self._drawSpectrum(dc, printerScale)
        
        # draw peaklist ticks
        if len(self.peaklistScaled) and (self.properties['showTicks'] or not len(self.spectrumPoints)):
            self._drawPeaklist(dc, printerScale)
    # ----
    
    
    def drawGel(self, dc, gelCoords, gelHeight, printerScale):
        """Draw gel."""
        
        # draw line spectrum gel
        if len(self.spectrumScaled) > 2 and self.properties['showSpectrum']:
            self._drawSpectrumGel(dc, gelCoords, gelHeight, printerScale)
        
        # draw peaklist gel
        elif len(self.peaklistScaled) and (self.properties['showSpectrum'] or self.properties['showLabels'] or self.properties['showTicks']):
            self._drawPeaklistGel(dc, gelCoords, gelHeight, printerScale)
        
        # draw gel legend
        self._drawGelLegend(dc, gelCoords, gelHeight, printerScale)
    # ----
    
    
    def makeLabels(self, dc, printerScale):
        """Get object labels."""
        
        # check labels
        if not self.properties['showLabels'] or not len(self.peaklistScaled):
            return []
        
        # set font
        dc.SetFont(_scaleFont(self.properties['labelFont'], printerScale['fonts']))
        
        # prepare labels
        labels = []
        format = '%0.'+`self.properties['labelDigits']`+'f'
        for x, peak in enumerate(self.peaklistScaled):
            
            # skip isotopes
            if not self.properties['showIsotopicLabels'] and self.peaklistCroppedPeaks[x].isotope != 0:
                continue
            
            # get position
            xPos = peak[0]
            yPos = peak[1]
            
            # get label
            label = format % self.peaklistCroppedPeaks[x].mz
            
            # add charge to label
            if self.properties['labelCharge'] and self.peaklistCroppedPeaks[x].charge != None:
                label += ' (%d)' % self.peaklistCroppedPeaks[x].charge
            
            # add group to label
            if self.properties['labelGroup'] and self.peaklistCroppedPeaks[x].group:
                label += ' [%s]' % self.peaklistCroppedPeaks[x].group
            
            # 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.peaklistCroppedPeaks[x].ai, label, textCoords, self.properties))
            
        return labels
    # ----
    
    
    def _drawSpectrum(self, dc, printerScale):
        """Draw spectrum lines."""
        
        # set pen and brush
        pen = wx.Pen(self.properties['spectrumColour'], self.properties['spectrumWidth']*printerScale['drawings'], self.properties['spectrumStyle'])
        brush = wx.Brush(self.properties['spectrumColour'], wx.SOLID)
        dc.SetPen(pen)
        dc.SetBrush(brush)
        
        # draw lines
        dc.DrawLines(self.spectrumScaled)
        
        # draw points if it makes sense
        count = len(self.spectrumScaled)
        if self.properties['showPoints'] \
            and count > 2 \
            and (self.spectrumScaled[2][0] - self.spectrumScaled[1][0]) > (6*printerScale['drawings']) \
            and ((self.spectrumScaled[-1][0] - self.spectrumScaled[0][0]) / count) > (6*printerScale['drawings']):
            
            for point in self.spectrumScaled:
                try: dc.DrawCircle(point[0], point[1], 2*printerScale['drawings'])
                except OverflowError: pass
    # ----
    
    
    def _drawSpectrumGel(self, dc, gelCoords, gelHeight, printerScale):
        """Draw spectrum gel."""
        
        # get plot coordinates
        gelY1, plotX1, plotY1, plotX2, plotY2, zeroY = gelCoords
        
        # correct zero
        if self.properties['flipped'] and (plotY1 < zeroY < plotY2):
            plotY1 = zeroY
            shift = zeroY
        elif (plotY1 < zeroY < plotY2):
            plotY2 = zeroY
            shift = plotY1
        else:
            shift = plotY1
        
        # set color step
        step = (plotY2 - plotY1) / 255
        if step == 0:
            return False
        
        # init brush
        dc.SetPen(wx.TRANSPARENT_PEN)
        brush = wx.Brush((255,255,255), wx.SOLID)
        dc.SetBrush(brush)
        
        # get first point and color
        lastX = round(self.spectrumScaled[0][0])
        lastY = 255
        previousX = lastX
        previousY = lastY
        maxY = 255
        
        # draw gel
        for point in self.spectrumScaled:
            
            # get point
            xPos = round(point[0])
            intens = round((point[1] - shift)/step)
            intens = min(intens, 255)
            intens = max(intens, 0)
            
            # reverse color for flipped spectra
            if self.properties['flipped']:
                intens = 255 - intens
            
            # filter points
            if xPos-lastX >= printerScale['drawings']:
                
                # set color if different
                if lastY != maxY:
                    brush.SetColour((maxY, maxY, maxY))
                    dc.SetBrush(brush)
                    
                # draw point rectangle
                try: dc.DrawRectangle(lastX, gelY1, xPos-lastX, gelHeight)
                except: pass
                
                # empty space
                if maxY < previousY and xPos-previousX > printerScale['drawings']:
                    maxY = previousY
                    brush.SetColour((maxY, maxY, maxY))
                    dc.SetBrush(brush)
                    try: dc.DrawRectangle(lastX+printerScale['drawings'], gelY1, xPos-(lastX+printerScale['drawings']), gelHeight)
                    except: pass
                
                # save last
                lastX = xPos
                lastY = maxY
                maxY = intens
            
            # remember previous
            previousX = xPos
            previousY = intens
                
            # get highest intensity
            maxY = min(intens, maxY)
    # ----
    
    
    def _drawPeaklist(self, dc, printerScale):
        """Draw peaklist ticks."""
        
        # set pen params
        peakPen = wx.Pen(self.properties['tickColour'], self.properties['tickWidth']*printerScale['drawings'], self.properties['tickStyle'])
        isotopePen = wx.Pen(self.properties['tickColour'], self.properties['tickWidth']*printerScale['drawings'], self.properties['tickStyle'])
        peakBrush = wx.Brush(self.properties['tickColour'], wx.SOLID)
        msmsBrush = wx.Brush(self.properties['tickColour'], wx.SOLID)
        
        if self.properties['isotopeColour']:
            isotopePen.SetColour(self.properties['isotopeColour'])
        if self.properties['msmsColour']:
            msmsBrush.SetColour(self.properties['msmsColour'])
        
        # draw isotopes
        dc.SetPen(isotopePen)
        for x, peak in enumerate(self.peaklistScaled):
            if self.peaklistCroppedPeaks[x].isotope != 0:
                try:
                    dc.DrawLine(peak[0], peak[2], peak[0], peak[1])
                    dc.DrawLine(peak[0]-3*printerScale['drawings'], peak[2], peak[0]+3*printerScale['drawings'], peak[2])
                except OverflowError:
                    pass
        
        # draw peaks
        dc.SetPen(peakPen)
        dc.SetBrush(peakBrush)
        for x, peak in enumerate(self.peaklistScaled):
            if self.peaklistCroppedPeaks[x].isotope == 0:
                try:
                    dc.DrawLine(peak[0], peak[2], peak[0], peak[1])
                    dc.DrawLine(peak[0]-3*printerScale['drawings'], peak[2], peak[0]+3*printerScale['drawings'], peak[2])
                    dc.DrawRectangle(peak[0]-1*printerScale['drawings'], peak[1]-1*printerScale['drawings'], 3*printerScale['drawings'], 3*printerScale['drawings'])
                except OverflowError:
                    pass
        
        # draw fragmentation mark
        dc.SetPen(wx.TRANSPARENT_PEN)
        dc.SetBrush(msmsBrush)
        for x, peak in enumerate(self.peaklistScaled):
            if self.peaklistCroppedPeaks[x].childScanNumber != None:
                try: dc.DrawCircle(peak[0], peak[1], 3*printerScale['drawings'])
                except OverflowError: pass
    # ----
    
    
    def _drawPeaklistGel(self, dc, gelCoords, gelHeight, printerScale):
        """Draw peaklist gel."""
        
        # get plot coordinates
        gelY1, plotX1, plotY1, plotX2, plotY2, zeroY = gelCoords
        
        # correct zero
        if self.properties['flipped'] and (plotY1 < zeroY < plotY2):
            plotY1 = zeroY
            shift = zeroY
        elif (plotY1 < zeroY < plotY2):
            plotY2 = zeroY
            shift = plotY1
        else:
            shift = plotY1
        
        # set color step
        step = (plotY2 - plotY1) / 255
        if step == 0:
            return False
        
        # init brush
        dc.SetPen(wx.TRANSPARENT_PEN)
        brush = wx.Brush((255,255,255), wx.SOLID)
        dc.SetBrush(brush)
        
        # get first point and color
        lastX = round(self.peaklistScaled[0][0])
        lastY = 255
        maxY = 255
        
        # draw rectangles
        last = len(self.peaklistScaled)-1
        for x, point in enumerate(self.peaklistScaled):
            
            # get intensity colour
            xPos = round(point[0])
            intens = round((point[1] - shift)/step)
            intens = min(intens, 255)
            intens = max(intens, 0)
            
            # reverse color for flipped spectra
            if self.properties['flipped']:
                intens = 255 - intens
            
            # draw first
            if x==0:
                brush.SetColour((intens, intens, intens))
                dc.SetBrush(brush)
                try: dc.DrawRectangle(xPos, gelY1, printerScale['drawings'], gelHeight)
                except: pass
                lastY = maxY
                maxY = intens
            
            # filter points
            if xPos-lastX >= printerScale['drawings']:
                
                # set color if different
                if lastY != maxY:
                    brush.SetColour((maxY, maxY, maxY))
                    dc.SetBrush(brush)
                    
                # draw peak line
                try: dc.DrawRectangle(lastX, gelY1, printerScale['drawings'], gelHeight)
                except: pass
                
                # save last
                lastX = xPos
                lastY = maxY
                maxY = intens
                
                # draw last
                if x==last:
                    brush.SetColour((maxY, maxY, maxY))
                    dc.SetBrush(brush)
                    try: dc.DrawRectangle(xPos, gelY1, printerScale['drawings'], gelHeight)
                    except: pass
                
                continue
                
            # get highest intensity
            maxY = min(intens, maxY)
    # ----
    
    
    def _drawGelLegend(self, dc, gelCoords, gelHeight, printerScale):
        """docstring for _drawGelLegend"""
        
        # get plot coordinates
        gelY1, plotX1, plotY1, plotX2, plotY2, zeroY = gelCoords
        
        # get colour
        if len(self.spectrumPoints) and self.properties['showSpectrum']:
            colour = self.properties['spectrumColour']
        else:
            colour = self.properties['tickColour']
        
        # set dc
        pencolour = [max(i-70,0) for i in colour]
        pen = wx.Pen(pencolour, 1*printerScale['drawings'], wx.SOLID)
        dc.SetPen(pen)
        dc.SetTextForeground(colour)
        dc.SetBrush(wx.Brush(colour, wx.SOLID))
        
        # draw legend circle
        x = plotX2 - 9 * printerScale['drawings']
        y = gelY1 + (gelHeight)/2
        dc.DrawCircle(x, y, 3*printerScale['drawings'])
        
        # draw legend text
        if self.properties['showGelLegend'] and self.properties['legend']:
            textSize = dc.GetTextExtent(self.properties['legend'])
            x = plotX2 - textSize[0] - 17*printerScale['drawings']
            y = gelY1 + gelHeight/2 - textSize[1]/2
            dc.DrawText(self.properties['legend'], x, y)
    # ----
    
    
    def _normalization(self):
        """Calculate normalization constants."""
        
        # get range from points and peaklist
        if len(self.spectrumPoints) and len(self.peaklistPoints):
            spectrumMinXY, spectrumMaxXY = self.spectrumBox
            peaklistMinXY, peaklistMaxXY = self.peaklistBox
            self.normalization = max(spectrumMaxXY[1], peaklistMaxXY[1]) / 100.
        
        # get range from points only
        elif len(self.spectrumPoints):
            minXY, maxXY = self.spectrumBox
            self.normalization = maxXY[1] / 100.
        
        # get range from peaklist only
        elif len(self.peaklistPoints):
            minXY, maxXY = self.peaklistBox
            self.normalization = maxXY[1] / 100.
    # ----
    
    


# HELPERS
# -------

def _scaleFont(font, scale):
    """Scale font."""
    
    # check printerScale
    if scale == 1:
        return font
    
    # get font
    pointSize = font.GetPointSize()
    family = font.GetFamily()
    style = font.GetStyle()
    weight = font.GetWeight()
    underline = font.GetUnderlined()
    faceName = font.GetFaceName()
    encoding = font.GetDefaultEncoding()
    
    # scale pointSize
    pointSize = pointSize * scale * 1.3
    
    # make print font
    printerFont = wx.Font(pointSize, family, style, weight, underline, faceName, encoding)
    
    return printerFont
# ----


def _scaleAndShift(points, scaleX, scaleY, shiftX, shiftY):
    """Scale and shift signal points used by plot. New array is returned.
        points (numpy array) - data points
        scaleX (float) - x-axis scale
        scaleY (float) - y-axis scale
        shiftX (float) - x-axis shift
        shiftY (float) - y-axis shift
    """
    
    # check signal type
    if not isinstance(points, numpy.ndarray):
        raise TypeError, "Signal points must be NumPy array!"
    if points.dtype.name != 'float64':
        raise TypeError, "Signal points must be float64!"
    
    # check signal data
    if len(points) == 0:
        return numpy.array([])
    
    # scale and shift signal
    return calculations.signal_rescale(points, float(scaleX), float(scaleY), float(shiftX), float(shiftY))
# ----


def _filterPoints(points, resolution):
    """Filter signal points according to resolution. New array is returned.
        points (numpy array) - data points
        resolution (float) - resolution point size
    """
    
    # check signal type
    if not isinstance(points, numpy.ndarray):
        raise TypeError, "Signal points must be NumPy array!"
    if points.dtype.name != 'float64':
        raise TypeError, "Signal points must be float64!"
    
    # check signal data
    if len(points) == 0:
        return numpy.array([])
    
    # filter signal
    return calculations.signal_filter(points, float(resolution))
# ----