C:/work/RevealedSystems/EyeSpy-RS/eyespy/src/objects/gui/figureAxesWrapper.py

Go to the documentation of this file.

# Copyright (C) 2008-2009  Mark Hanegraaff
#
# 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.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.

import wx
from objects.logic.common.globalStrings import globalStrings


## The figureAxesWrapper class contains several wrapper and helper functions to manipulate the Matplotlib Axes objects.
# Any conversion (screen to map and vice versa), scaling, zooming and panning methods will be found here.
#
# For additional information, please refer to the MatplotLib documentation 
class figureAxesWrapper():
    
    ## Default constructor
    # @param ax This is the Axes object returned from the Figure.add_axes(...) method
    def __init__(self, ax):
        self.axes = ax
        
        # current zoom setting
        self.currentXAxis = None
        self.currentYAxis = None
        
        # full zoom settings
        self.fullXAxis = None
        self.fullYAxis = None
        
        
    
    ## Returns the zoom factor, computed by looking at the current Y Axis.
    # Zooming and panning in MatplotLib can be achieved setting the current axes to some
    # fraction of the figure Axes.S
    # For example, if the X axes range is (0, 100), then setting a new range of (25, 75) will be the equivalent of a 200% zoom.
    # Similarly, by changing these numbers one can also achieve a panning effect.
    # @return Tuple 
    def getZoomFactor(self):
        return abs(self.currentYAxis[1] - self.currentYAxis[0])
        
    
    ## Convert the mouse XY coordinates (from MouseEvent) into map longitude/latitude
    # coordinates.
    # @param mouseX Screen X position as determined by a mouse event
    # @param mouseY Screen Y position as determined by a mouse event
    # @param main_map BaseMap object
    # @return longitude, latitude as Floats
    def getLonLatFromMouseXY(self, mouseX, mouseY, main_map):
        mouseMapX, mouseMapY = self.axes.transData.inverse_xy_tup( (mouseX,mouseY) )                
        mouseMapX, mouseMapY = self.axes.transData.inverse_xy_tup( (mouseX,mouseY) )
        
        #MH##mouseMapX, mouseMapY = self.axes.transData.inverted().transform( (mouseX,mouseY) )                
        #MH##mouseMapX, mouseMapY = self.axes.transData.inverted().transform( (mouseX,mouseY) )
        
        lon, lat = main_map(mouseMapX, mouseMapY, True)
        
        return lon, lat
    
    ## Convert the mouse X/Y coordinates (from MouseEvent) to Figure axes X/Y values
    # coordinates.
    # @param mouseX Screen X position as determined by a mouse event
    # @param mouseY Screen Y position as determined by a mouse event    
    # @return Axes X, Y values as Integers
    def getAxesXYFromMouseXY(self, mouseX, mouseY):
        axesX, axesY = self.axes.transData.inverse_xy_tup( (mouseX,mouseY) )                
        #MH##axesX, axesY = self.axes.transData.inverted().transform( (mouseX,mouseY) )
        
        return axesX, axesY
    
    ## Sets the new zoom values expressed in terms of new Figure Axes values
    # @param xlim new X Axes value
    # @param ylim new Y Axes value
    def setCurrentXYLim(self, xlim, ylim):
        self.currentXAxis = xlim
        self.currentYAxis = ylim
        
        self.axes.set_xlim(xlim)
        self.axes.set_ylim(ylim)
    
    ## sets the minimum zoom values. These are the Axes values which are used to determine
    # when you are zoomed out all the way
    # @param xlim new X Axes limit
    # @param ylim new Y Axes limit
    def setFullXYLim(self, xlim, ylim):
        self.fullXAxis = xlim
        self.fullYAxis = ylim
    
    ## Returns the minimum zoom value. I.e the "Zoomed all the way out" value.
    # Typically this is only called once (when the map is created).        
    def computeFullXYLim(self):
        self.fullXAxis = self.axes.get_xlim()
        self.fullYAxis = self.axes.get_ylim()
    
    ## Returns the current X, Y Axes values
    # @return current X Axes, current Y Axes
    def getCurrentXYLim(self):
        return self.currentXAxis, self.currentYAxis
    
    
    ## adjusts the X and Y axes to match the same aspect ratio as a
    # whatever the Canavas just changed to.
    # This is usually in response to the user resizing the screen, and therefore changing the shape of the screen rectangle.
    # @param newCanavasSize New Canavas Size.
    def adjustAxisToCanavas(self, newCanavasSize):

        x1, y1 = self.axes.transData.xy_tup( (self.currentXAxis[0], self.currentYAxis[0]) )
        x2, y2 = self.axes.transData.xy_tup( (self.currentXAxis[1], self.currentYAxis[1]) )
        #MH#x1, y1 = self.axes.transData.transform( (self.currentXAxis[0], self.currentYAxis[0]) )
        #MH#x2, y2 = self.axes.transData.transform( (self.currentXAxis[1], self.currentYAxis[1]) )
        
        frm = wx.Point()
        to = wx.Point()
        
        frm.x=x1;frm.y=y1;to.x=x2;to.y=y2
        
        # since the from/to did not change, this will essentially just change the aspect
        self.freeZoomChangeAspect(frm, to, newCanavasSize, False)
        
 
    
    ## Zoom (i.e change the X/Y Axes values) using the results of a from/to rectangle.
    # Note the this will not sync with the main window's aspect ratio.
    # @param frm wx.Point
    # @param to wx.Point
    def freeZoom(self, frm, to):
        # normalize values
        if (frm.x > to.x):
            normStartX, normEndX = to.x, frm.x
        else:
            normStartX, normEndX = frm.x, to.x
            
        if (frm.y > to.y):
            normStartY, normEndY = to.y, frm.y
        else:
            normStartY, normEndY = frm.y, to.y

        startX, startY = self.axes.transData.inverse_xy_tup( (normStartX, normStartY) )
        endX, endY = self.axes.transData.inverse_xy_tup( (normEndX, normEndY) )
        #MH##startX, startY = self.axes.transData.inverted().transform( (normStartX, normStartY) )
        #MH##endX, endY = self.axes.transData.inverted().transform( (normEndX, normEndY) )
        
        self.setCurrentXYLim((startX, endX),(startY, endY))
    
    
    
    ## Zoom (i.e change the X/Y Axes) using the results of a from/to rectangle.
    # Note the this will sync with the main window's aspect ratio, so actual zoom amount will be approximated to some degree.
    # @param frm wx.Point
    # @param to wx.Point
    # @param canavas The canvas, whose aspect ratio must be matched.
    # @param validateSelectionSize If True, it will not allow the user to zoom if the from to rectangle is too small.
    # This is done to prevent the user from accidentally dragging the mouse (and then zooming in way too far) when in Zoom mode.
    def freeZoomChangeAspect(self, frm, to, canavas, validateSelectionSize=True):        
        
        #1) normalize values
        if (frm.x > to.x):
            normStartX, normEndX = to.x, frm.x
        else:
            normStartX, normEndX = frm.x, to.x
            
        if (frm.y > to.y):
            normStartY, normEndY = to.y, frm.y
        else:
            normStartY, normEndY = frm.y, to.y
        
            
        #2) figure out aspect ratios
        propX, propY = canavas
        
        # validate
        if propY == 0: return
        if normEndY - normStartY == 0: return
        
        canavasAspectRatio = float(propX)/float(propY)
        marquisAspectRatio = float(abs(normEndX - normStartX)) / float(abs(normEndY - normStartY))
        
        # this value could vary, but a 5-1 or 1-5 ratio for a marquis selection is probably 
        # the result of the user making an error
        #
        if validateSelectionSize == True:
            if marquisAspectRatio > 5 or marquisAspectRatio < 0.2:
                return  
        
        if canavasAspectRatio == 0: return
        
        # need to strech the X axis
        if (canavasAspectRatio > 1):
            newWidth = abs(normEndY - normStartY) * canavasAspectRatio
            
            # this is the amount we need to stretch the x axis by
            deltaWidth = (newWidth / 2) - (abs(normEndX - normStartX)  / 2)            
    
            # now just adjust the X axis            
            normStartX = normStartX - deltaWidth
            normEndX   = normEndX + deltaWidth

        else: #strech the Y axis only
            newHeight = abs(normEndX - normStartX) / canavasAspectRatio
            
            # this is the amount we need to stretch the Y axis by
            deltaHeight = (newHeight / 2) - (abs(normEndY - normStartY)  / 2)        
    
            # now just adjust the Y axis            
            normStartY = normStartY - deltaHeight
            normEndY  = normEndY + deltaHeight

        
        tStartX, tStartY = self.axes.transData.inverse_xy_tup( (normStartX, normStartY) )
        tEndX, tEndY = self.axes.transData.inverse_xy_tup( (normEndX, normEndY) )
        #MH##tStartX, tStartY = self.axes.transData.inverted().transform( (normStartX, normStartY) )
        #MH##tEndX, tEndY = self.axes.transData.inverted().transform( (normEndX, normEndY) )
        
        
        # make sure we do not exceed our mins and maxes
        if tStartX < self.fullXAxis[0]:startX = self.fullXAxis[0]
        else:startX = tStartX
        
        if tEndX > self.fullXAxis[1]:endX = self.fullXAxis[1]
        else:endX = tEndX
        
        if tStartY < self.fullYAxis[0]:startY = self.fullYAxis[0]
        else:startY = tStartY
        
        if tEndY > self.fullYAxis[1]:endY = self.fullYAxis[1]
        else:endY = tEndY
        
        # reset the limits
        self.setCurrentXYLim((startX, endX),(startY, endY))        
    
    ## Zoom in using some fixed amount. The lack of a from/to rectangle means that we are zooming straight in
    # (i.e like when using the mouse scroll)
    # @param canavas Canavas object whose aspect ratio we are trying to preserve 
    def zoomIn(self, canavas):
        xLim, yLim = self.getCurrentXYLim()
        
        xLen = abs(xLim[1] - xLim[0])
        yLen = abs(yLim[1] - yLim[0])
        
        # let's try a 20% zoom in factor
        xDelta = (xLen * 0.2) / 2
        yDelta = (yLen * 0.2) / 2
                
        self.setCurrentXYLim((xLim[0] + xDelta, xLim[1] - xDelta),(yLim[0] + yDelta, yLim[1] - yDelta))
        self.adjustAxisToCanavas(canavas)
    
    
    
    ## Zoom out using some fixed amount. The lack of a from/to rectangle means that we are zooming straight out
    # (i.e like when using the mouse scroll)
    # @param canavas Canavas object whose aspect ratio we are trying to preserve 
    def zoomOut(self, canavas):
        
        #xLim = self.fullXAxis
        #yLim = self.fullYAxis
        
        xLim, yLim = self.getCurrentXYLim()
        
        xLen = abs(xLim[1] - xLim[0])
        yLen = abs(yLim[1] - yLim[0])
        
        # let's try a 20% zoom in factor
        xDelta = (xLen * 0.2) / 2
        yDelta = (yLen * 0.2) / 2
        
        # check to see how much I can really zoom out
        canExpandLeft    = (xLim[0] - xDelta) >= self.fullXAxis[0]
        canExpandRight   = (xLim[1] + xDelta) <= self.fullXAxis[1]
        canExpandBottom  = (yLim[0] - yDelta) >= self.fullYAxis[0]
        canExpandTop     = (yLim[1] + yDelta) <= self.fullYAxis[1]
        
        xMin, xMax, yMin, yMax = 0, 0, 0, 0
        
        if canExpandLeft and canExpandRight:
            xMin = xLim[0] - xDelta
            xMax = xLim[1] + xDelta
            
        elif not canExpandLeft and not canExpandRight:
            xMin = self.fullXAxis[0]
            xMax = self.fullXAxis[1]
            
        elif not canExpandLeft and canExpandRight:
            extraSpace = abs(xLim[0] - xDelta)
            xMin = self.fullXAxis[0]            
            xMax = xLim[1] + xDelta + extraSpace            
            if xMax > self.fullXAxis[1]: xMax = self.fullXAxis[1]
                        
        else:
            extraSpace = abs(self.fullXAxis[1] - (xLim[1] + xDelta))
            xMin = xLim[0] - xDelta - extraSpace            
            if xMin < self.fullXAxis[0]: xMin = self.fullXAxis[0]            
            xMax = self.fullXAxis[1]
            
            
        if canExpandBottom and canExpandTop:
            yMin = yLim[0] - yDelta
            yMax = yLim[1] + yDelta
            
        elif not canExpandBottom and not canExpandTop:
            yMin = self.fullYAxis[0]
            yMax = self.fullYAxis[1]
            
        elif not canExpandBottom and canExpandTop:
            extraSpace = abs(yLim[0] - yDelta)
            yMin = self.fullYAxis[0]            
            yMax = yLim[1] + yDelta + extraSpace            
            if yMax > self.fullYAxis[1]: yMax = self.fullYAxis[1]
                        
        else:
            extraSpace = abs(self.fullYAxis[1] - (yLim[1] + yDelta))
            yMin = yLim[0] - yDelta - extraSpace            
            if yMin < self.fullYAxis[0]: yMin = self.fullYAxis[0]            
            yMax = self.fullYAxis[1]
            
        
            
        
        self.setCurrentXYLim((xMin, xMax), (yMin, yMax))
        self.adjustAxisToCanavas(canavas)

    
    
    
    ## Initialize Zoom values (during map initialization)
    def resetZoom(self):
        self.axes.set_xlim(self.fullXAxis)
        self.axes.set_ylim(self.fullYAxis)
        
        self.currentXAxis = tuple(self.fullXAxis)  
        self.currentYAxis = tuple(self.fullYAxis)
      
      
    ## Reset the Zoom values (Part of the map's redraw cycle)  
    def resetCurrentZoom(self):
        self.axes.set_xlim(self.currentXAxis)                
        self.axes.set_ylim(self.currentYAxis)
    
    
    ## Pan to a new location screen location
    # @param frm From location. Used to calculate the Pan Amount
    # @param to To location. Used to calculate the Pan Amount
    def pan(self, frm, to):
        
        if frm is None or to is None: return        
        
        startX, startY = self.axes.transData.inverse_xy_tup( (frm.x, frm.y) )
        endX, endY = self.axes.transData.inverse_xy_tup( (to.x, to.y) )
        #MH##startX, startY = self.axes.transData.inverted().transform( (frm.x, frm.y) )
        #MH##endX, endY = self.axes.transData.inverted().transform( (to.x, to.y) )
 
        dx = endX - startX
        dy = endY - startY 
        
        panXmin = self.currentXAxis[0] - dx
        panXmax = self.currentXAxis[1] - dx
           
        panYmin = self.currentYAxis[0] + dy
        panYmax = self.currentYAxis[1] + dy

            # don't pan beyond the original map boundaries
        if panXmin < self.fullXAxis[0] or panXmax > self.fullXAxis[1]:
            if (panXmin < self.fullXAxis[0]):
                panXmin = self.fullXAxis[0]
                panXmax = self.currentXAxis[1] + (panXmin - self.currentXAxis[0])
            else:                                
                panXmax = self.fullXAxis[1]
                panXmin = self.currentXAxis[0] + (panXmax - self.currentXAxis[1])
        
        if panYmin < self.fullYAxis[0] or panYmax > self.fullYAxis[1]:
            if (panYmin < self.fullYAxis[0]):
                panYmin = self.fullYAxis[0]
                panYmax = self.currentYAxis[1] + (panYmin - self.currentYAxis[0])
            else:                                
                panYmax = self.fullYAxis[1]
                panYmin = self.currentYAxis[0] + (panYmax - self.currentYAxis[1])
                
        
        self.axes.set_xlim((panXmin, panXmax))            
        self.axes.set_ylim((panYmin, panYmax))
        
        self.currentXAxis = tuple((panXmin, panXmax))
        self.currentYAxis = tuple((panYmin, panYmax))
        
        
    

---