Texture viewer widget

Question

I have a little project going on and so far I'm not really having any problems. But since I haven't internalized all of Python's core features yet, I'm pretty sure my code offers pretty many subjects to optimize.

Please point out anything that could be done better. For example, I'm feeling uncomfortable with the method updateMousePosition as it seems kind of ugly to me.

#!/usr/bin/python   
import sys

from PySide import QtCore, QtGui
from PySide.QtGui import QWidget, QApplication, QPixmap, QLabel

from UI_TextureViewer import Ui_UI_TextureViewer
from ExtendedLabel import ExtendedLabel

class TextureViewer(QWidget, Ui_UI_TextureViewer):
    """ A widget that displays a single texture.

    The textures resides in a ExtendedLabel (which enables connecting to a
    mouseMovedSignal) which is put inside a QScrollArea to enable arbitrary
    zooming.
    The widget also shows the u and v coordinates based on the position of the
    mouse."""

    def __init__(self, filename, parent=None):
        """ Default ctor.

        Connects all buttons, loads the texture from file and sets up a default
        zoom value of 1.0"""

        super(TextureViewer, self).__init__(parent)
        self.setupUi(self)
        self.filename = filename

        self.buttonZoomIn.clicked.connect(self.zoomIn)
        self.buttonZoomOut.clicked.connect(self.zoomOut)
        self.buttonResetZoom.clicked.connect(self.resetZoom)

        self.u = 0
        self.v = 0

        self.labelFilename.setText(filename)
        self.zoomValue = 1.0

        self.loadImage()

    def loadImage(self):
        """ Loads the image stored in self.filename and sets up the labels
        showing information about the original (umzoomed) image. """

        self.image = QPixmap()
        self.image.load(self.filename)
        imgs = [str(self.image.size().width()), str(self.image.size().height())]
        self.labelSize.setText("x".join(imgs))
        self.zoom(self.zoomValue)

    def zoom(self, factor):
        """ Zooms the texture by the given factor.
        Zooming is achieved by creating a scaled copy of the original image and
        showing it by setting setPixmap of an ExtendedLabel. """

        imageLabel = ExtendedLabel()
        imageLabel.setAlignment(QtCore.Qt.AlignLeft | QtCore.Qt.AlignTop)
        imageLabel.mouseMovedSignal.connect(self.updateMousePosition)
        ow, oh = [self.image.size().width(), self.image.size().height()]
        sw, sh = [ow * factor, oh * factor]
        zoomedImage = self.image.scaled(sw, sh)
        imageLabel.setPixmap(zoomedImage)
        self.scrollArea.setWidget(imageLabel)
        self.updateZoomLabel()

    def updateZoomLabel(self):
        """ Updates the label that shows the current zoom value. """
        f = self.zoomValue * 100.0
        self.labelZoom.setText("{0:.0f}%".format(f))

    def zoomIn(self):
        """ Zooms in 25% on the image. """
        self.zoomValue += 0.25
        self.zoom(self.zoomValue)

    def zoomOut(self):
        """ Zooms out 25% of the image.
        If the zoom value is less than 25%, then the step size is decreased to
        5%. Total zoom level is clamped to 5%. """
        if self.zoomValue <= 0.25:
            v = 0.05
        else:
            v = 0.25
        if self.zoomValue - v > 0.05:
            self.zoomValue -= v
            self.zoom(self.zoomValue)

    def resetZoom(self):
        """ Resets the zoom factor to 1.0. """
        self.zoomValue = 1.0
        self.zoom(self.zoomValue)

    def updateMousePosition(self, event):
        """ Slot that is called by the mouseMovedSignal of the ExtendedLabel
        which shows the image.
        Computes the u and v coordinates of the current mouse position and
        updates the labels showing the coordinates. """
        absx, absy = [event.x(), event.y()]
        sx, sy = [self.image.width() * self.zoomValue,
             self.image.height() * self.zoomValue]
        self.u = float(absx) / float(sx)
        self.v = float(absy) / float(sy)
        if self.u > 1.0:
            self.u = 1.0
        if self.v > 1.0:
            self.v = 1.0
        self.labelU.setText("{0:.4f}".format(self.u))
        self.labelV.setText("{0:.4f}".format(self.v))

if __name__ == '__main__':
    app = QApplication(sys.argv)
    frame = TextureViewer("../../media/textures/DarkGrass.png")
    frame.show()
    app.exec_()

Answer 1

A few things I can see that will clean up the code a tad are:

def updateMousePosition(self, event):
    """ Slot that is called by the mouseMovedSignal of the ExtendedLabel
    which shows the image.
    Computes the u and v coordinates of the current mouse position and
    updates the labels showing the coordinates. """
    sx = self.image.width() * self.zoomValue
    sy = self.image.height() * self.zoomValue
    self.u = min(float(event.x()) / float(sx), 1.0)
    self.v = min(float(event.y()) / float(sy), 1.0)
    self.labelU.setText("{0:.4f}".format(self.u))
    self.labelV.setText("{0:.4f}".format(self.v))

absx and absy are used once, so I don't see a point in assigning them to temp vars. I'd put sx/sy on separate lines. (As an aside, your use of square brackets is pretty spurious as "x,y = 1,2" has the same net effect as "x,y = [1,2]" without the creation of a temp list.) Your if's are basically capping self.u and self.v at 1.0. Also are you actually using the self.v and self.u anywhere else or are they just locals to get the values for the setText() calls? If so, they could just be local variables like f in updateZoomLabel().