LapGUI.py

#Based off of http://wiki.wxpython.org/GLCanvas
#Lots of help from http://wiki.wxpython.org/Getting%20Started
import sys
sys.path.append("S3DGLPy")
from OpenGL.GL import *
from OpenGL.arrays import vbo
import wx
from wx import glcanvas

from Primitives3D import *
from PolyMesh import *
from LaplacianMesh import *
from Cameras3D import *
from MeshCanvas import *
from struct import *
from sys import exit, argv
import random
import numpy as np
import scipy.io as sio
from pylab import cm
import os
import math
import time
from time import sleep
from pylab import cm
import matplotlib.pyplot as plt
from ColorTextureTools import *

#LAPLACIAN MESH CONSTANTS
SPECTRUM_K = 20
LOWPASS_K = 20
HEAT_K = 200
HKS_K = 200
HKS_T = 20

#GUI States
(STATE_NORMAL, STATE_CHOOSELAPLACEVERTICES, STATE_CHOOSECOLORVERTICES, STATE_ANIMATEHEAT) = (0, 1, 2, 3)
#Laplacian substates
(SUBSTATE_NONE, CHOOSELAPLACE_WAITING, CHOOSELAPLACE_PICKVERTEX) = (0, 1, 2)
#Color picking substates
(COLORPICK_NONE, COLORPICK_WAITING, COLORPICK_PICKVERTEX, COLORPICK_PICKCOLOR) = (0, 1, 2, 3)

class MeshViewerCanvas(BasicMeshCanvas):
    def __init__(self, parent):
        super(MeshViewerCanvas, self).__init__(parent)
        self.GUIState = STATE_NORMAL
        self.GUISubstate = SUBSTATE_NONE
        
        #State variables for laplacian mesh operations
        self.laplacianConstraints = {} #Elements will be key-value pairs (idx, Point3D(new position))
        self.laplaceCurrentIdx = -1
        
        #State variables for heat, etc
        (self.eigvalues, self.eigvectors) = (np.array([]), np.array([]))
        self.heatIdx = 0
        self.heat_ts = np.linspace(0, 1000, 100)
        
        #State variables for color picking
        self.colorChoices = {} #Elements will be key-value paris (idx, np.array([R, G, B]))
        self.colorCurrentIdx = -1
        self.colorPickTexID = None
        self.colorPosVBO = None
        self.colorColorVBO = None
    
    def displayMeshFacesCheckbox(self, evt):
        self.displayMeshFaces = evt.Checked()
        self.Refresh()

    def displayMeshEdgesCheckbox(self, evt):
        self.displayMeshEdges = evt.Checked()
        self.Refresh()

    def displayMeshVerticesCheckbox(self, evt):
        self.displayMeshVertices = evt.Checked()
        self.Refresh()

    def displayVertexNormalsCheckbox(self, evt):
        self.displayVertexNormals = evt.Checked()
        self.Refresh()

    def displayFaceNormalsCheckbox(self, evt):
        self.displayFaceNormals = evt.Checked()
        self.Refresh()

    def useLightingCheckbox(self, evt):
        self.useLighting = evt.Checked()
        self.needsDisplayUpdate = True
        self.Refresh()
    
    def useTextureCheckbox(self, evt):
        self.useTexture = evt.Checked()
        self.needsDisplayUpdate = True
        self.Refresh()    
    
    #######Laplacian mesh menu handles
    def doLaplacianMeshSelectVertices(self, evt):
        if self.mesh:
            self.mesh.updateIndexDisplayList()
            self.GUIState = STATE_CHOOSELAPLACEVERTICES
            self.GUISubstate = CHOOSELAPLACE_WAITING
            self.Refresh()
    
    def clearLaplacianMeshSelection(self, evt):
        self.laplacianConstraints.clear()
        self.Refresh()
    
    def getAnchors(self):
        anchors = np.zeros((len(self.laplacianConstraints), 3))
        i = 0
        anchorsIdx = []
        for anchor in self.laplacianConstraints:
            anchorsIdx.append(anchor)
            anchors[i, :] = self.laplacianConstraints[anchor]
            i += 1
        anchorsIdx = np.array(anchorsIdx)
        return (anchors, anchorsIdx)
    
    def getSelectedColors(self):
        colors = np.zeros((len(self.colorChoices), 3))
        colorsIdx = []
        i = 0
        for idx in self.colorChoices:
            colorsIdx.append(idx)
            colors[i, :] = self.colorChoices[idx]
            i += 1
        return (colors, colorsIdx)
    
    def doLaplacianSolveWithConstraints(self, evt):
        (anchors, anchorsIdx) = self.getAnchors()        
        solveLaplacianMesh(self.mesh, anchors, anchorsIdx)
        self.mesh.needsDisplayUpdate = True
        self.mesh.updateIndexDisplayList()
        self.Refresh()
    
    def estimateCurvature(self, evt):
        #Color vertices to be equal to mean curvature
        curvs = estimateMeanCurvature(self.mesh)
        curvs = curvs - np.min(curvs)
        curvs = curvs / np.max(curvs)
        cmConvert = cm.get_cmap('jet')
        self.mesh.VColors = cmConvert(curvs)[:, 0:3]
        self.mesh.needsDisplayUpdate = True
    
    def doLaplacianSmooth(self, evt):
        doLaplacianSmooth(self.mesh)
        self.mesh.needsDisplayUpdate = True
        self.Refresh()

    def doLaplacianSharpen(self, evt):
        doLaplacianSharpen(self.mesh)
        self.mesh.needsDisplayUpdate = True
        self.Refresh()
    
    def doMinimalSurface(self, evt):
        (anchors, anchorsIdx) = self.getAnchors()        
        makeMinimalSurface(self.mesh, anchors, anchorsIdx)
        #solveLaplacianMesh(self.mesh, anchors, anchorsIdx)
        self.mesh.needsDisplayUpdate = True
        self.mesh.updateIndexDisplayList()
        self.Refresh()

    def getSpectrum(self, evt):
        cmap = plt.get_cmap('jet')
        (VPos, ITris) = (self.mesh.VPos, self.mesh.ITris)
        K = SPECTRUM_K
        if (K >= self.mesh.VPos.shape[0]):
            K = self.mesh.VPos.shape[0]-1
        (lam, U) = getLaplacianSpectrum(self.mesh, K)
        for k in range(U.shape[1]):
            Y = np.zeros(U.shape[0])
            if k > 0:
                Y = U[:, k]
                Y = Y - np.min(Y)
                Y = Y/np.max(Y)
            VColors = np.array(np.round(255.0*cmap(Y)[:, 0:3]), dtype=np.int64)
            saveOffFileExternal("spectrum%i.off"%k, VPos, VColors, ITris)
    
    def doLowpass(self, evt):
        K = LOWPASS_K
        if (K >= self.mesh.VPos.shape[0]):
            K = self.mesh.VPos.shape[0]-1
        doLowpassFiltering(self.mesh, K)
        self.mesh.needsDisplayUpdate = True
        self.mesh.updateIndexDisplayList()
        self.Refresh()
    
    def doHeat(self, evt):
        K = HEAT_K
        if (K >= self.mesh.VPos.shape[0]):
            K = self.mesh.VPos.shape[0]-1
        (self.eigvalues, self.eigvectors) = getLaplacianSpectrum(self.mesh, K)
        self.GUIState = STATE_ANIMATEHEAT
        self.heatIdx = 0
        self.heat_ts = np.linspace(0, 1.0/self.eigvalues[1], 100)
        self.Refresh()

    def doHKS(self, evt):
        K = HKS_K
        if (K >= self.mesh.VPos.shape[0]):
            K = self.mesh.VPos.shape[0]-1
        heat = getHKS(self.mesh, K, HKS_T)
        heat = heat/np.max(heat)
        cmap = plt.get_cmap('jet')
        self.mesh.VColors = cmap(heat)[:, 0:3]
        self.mesh.needsDisplayUpdate = True
        self.Refresh()
    
    def doFlattening(self, evt):
        (anchors, quadIdxs) = self.getAnchors()
        doFlattening(self.mesh, quadIdxs)
        self.mesh.needsDisplayUpdate = True
        self.mesh.updateIndexDisplayList()
        self.Refresh()
    
    def doUVCoords(self, evt):
        (anchors, quadIdxs) = self.getAnchors()
        U = getTexCoords(self.mesh, quadIdxs)
        self.mesh.VTexCoords = U
        if self.mesh.texID == -1:
            self.mesh.texID = loadTexture("texture.png")
            print "Loaded texture: ", self.mesh.texID
        self.useTexture = True
        self.parent.useTextureCheckbox.SetValue(True)
        self.mesh.needsDisplayUpdate = True
        self.Refresh()
    
    ##Color callbacks
    def doSelectColorVertices(self, evt):
        if self.mesh:
            self.mesh.updateIndexDisplayList()
            self.GUIState = STATE_CHOOSECOLORVERTICES
            self.GUISubstate = COLORPICK_WAITING
            self.colorCurrentIdx = -1
            self.Refresh()
    
    def clearColorVertexSelection(self, evt):
        self.colorChoices.clear()
    
    def doInterpolateColors(self, evt):
        if not self.mesh:
            return
        (colors, colorsIdx) = self.getSelectedColors()
        if len(colorsIdx) == 0:
            return
        self.mesh.VColors = smoothColors(self.mesh, colors/255.0, colorsIdx)
        for k in range(3):
            self.mesh.VColors[self.mesh.VColors[:, k] < 0.0, k] = 0
            self.mesh.VColors[self.mesh.VColors[:, k] > 1.0 , k] = 1.0
        print self.mesh.VColors
        self.mesh.needsDisplayUpdate = True
        self.Refresh()
    
    def updateColorChoiceBuffers(self):
        #Remake color and vertex buffers
        if self.colorPosVBO:
            self.colorPosVBO.delete()
        if self.colorColorVBO:
            self.colorColorVBO.delete()
        N = len(self.colorChoices)
        Pos = np.zeros((N, 3))
        Colors = np.zeros((N, 3))
        i = 0
        for idx in self.colorChoices:
            Pos[i, :] = self.mesh.VPos[idx, :]
            Colors[i, :] = self.colorChoices[idx]/255.0
            i += 1
        self.colorPosVBO = vbo.VBO(np.array(Pos, dtype=np.float32))
        self.colorColorVBO = vbo.VBO(np.array(Colors, dtype=np.float32))
    
    def drawMeshStandard(self):
        glEnable(GL_LIGHTING)
        glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, [0.8, 0.8, 0.8, 1.0])
        glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, [0.2, 0.2, 0.2, 1.0])
        glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, 64)
        self.camera.gotoCameraFrame()
        glLightfv(GL_LIGHT0, GL_POSITION, np.array([0, 0, 0, 1]))
        self.mesh.renderGL(self.displayMeshEdges, self.displayMeshVertices, self.displayMeshFaces, self.displayVertexNormals, self.displayFaceNormals, self.useLighting, self.useTexture)

    def repaint(self):
        self.setupPerspectiveMatrix()
        
        glClearColor(0.0, 0.0, 0.0, 0.0)
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
        
        if self.GUIState == STATE_NORMAL and self.mesh:
            self.drawMeshStandard()        
        elif self.GUIState == STATE_ANIMATEHEAT and self.eigvectors.size > 0 and self.eigvalues.size > 0:
            cmap = plt.get_cmap('jet')
            (anchors, anchorsIdx) = self.getAnchors()
            heat = getHeat(self.mesh, self.eigvalues, self.eigvectors, self.heat_ts[self.heatIdx], anchorsIdx)
#            if self.heatIdx == 0:
#                self.heatScale = np.max(heat)
#            heat = heat/self.heatScale
            self.mesh.VColors = cmap(heat)[:, 0:3]
            if self.mesh.VColorsVBO:
                self.mesh.VColorsVBO.delete()
            self.mesh.VColorsVBO = vbo.VBO(np.array(self.mesh.VColors, dtype=np.float32))
            self.drawMeshStandard()
            saveImageGL(self, "heat%i.png"%self.heatIdx)
            self.heatIdx += 1
            if self.heatIdx >= len(self.heat_ts):
                self.GUIState = STATE_NORMAL
            self.Refresh()
        elif self.GUIState == STATE_CHOOSELAPLACEVERTICES:
            if self.GUISubstate == CHOOSELAPLACE_WAITING:
                self.camera.gotoCameraFrame()
                glDisable(GL_LIGHTING)
                glPointSize(10)
                glBegin(GL_POINTS)
                for idx in self.laplacianConstraints:
                    P = self.mesh.VPos[self.mesh.vertices[idx].ID, :]
                    glColor3f(0, 1, 0)
                    glVertex3f(P[0], P[1], P[2])
                    P = self.laplacianConstraints[idx]
                    if idx == self.laplaceCurrentIdx:
                        glColor3f(1, 0, 0)
                    else:
                        glColor3f(0, 0, 1)
                    glVertex3f(P[0], P[1], P[2])
                glEnd()
                glColor3f(1, 1, 0)
                glBegin(GL_LINES)
                for idx in self.laplacianConstraints:
                    P1 = self.mesh.VPos[self.mesh.vertices[idx].ID, :]
                    P2 = self.laplacianConstraints[idx]
                    glVertex3f(P1[0], P1[1], P1[2])
                    glVertex3f(P2[0], P2[1], P2[2])
                glEnd()
                self.drawMeshStandard()
                
            elif self.GUISubstate == CHOOSELAPLACE_PICKVERTEX:
                glClearColor(0.0, 0.0, 0.0, 0.0)
                glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
                self.camera.gotoCameraFrame()
                self.mesh.renderGLIndices()
                pixel = glReadPixels(self.MousePos[0], self.MousePos[1], 1, 1, GL_RGBA, GL_UNSIGNED_BYTE)
                [R, G, B, A] = [int(pixel.encode("hex")[i*2:(i+1)*2], 16) for i in range(4)]
                idx = extractFromRGBA(R, G, B, 0) - 1
                if idx >= 0 and idx < len(self.mesh.vertices):
                    if idx in self.laplacianConstraints:
                        #De-select if it's already selected
                        self.laplaceCurrentIdx = -1
                        self.laplacianConstraints.pop(idx, None)
                    else:
                        self.laplacianConstraints[idx] = np.array(self.mesh.VPos[self.mesh.vertices[idx].ID, :])
                        self.laplaceCurrentIdx = idx
                self.GUISubstate = CHOOSELAPLACE_WAITING
                self.Refresh()
                
        elif self.GUIState == STATE_CHOOSECOLORVERTICES:
            if self.GUISubstate == COLORPICK_WAITING:
                self.drawMeshStandard()
                if not self.colorPickTexID:
                    self.colorPickTexID = getColorPickingTexture()
                if self.colorPosVBO:
                    self.camera.gotoCameraFrame()
                    glDisable(GL_LIGHTING)
                    glEnableClientState(GL_VERTEX_ARRAY)
                    glEnableClientState(GL_COLOR_ARRAY)
                    self.colorPosVBO.bind()
                    glVertexPointerf(self.colorPosVBO)
                    self.colorColorVBO.bind()
                    glColorPointerf(self.colorColorVBO)
                    glPointSize(10)
                    glDrawArrays(GL_POINTS, 0, len(self.colorChoices))
                    self.colorPosVBO.unbind()
                    self.colorColorVBO.unbind()
                    glDisableClientState(GL_COLOR_ARRAY)
                    glDisableClientState(GL_VERTEX_ARRAY)
                drawColorPicker(self.size.width, self.size.height, self.colorPickTexID)
                
            elif self.GUISubstate == COLORPICK_PICKVERTEX:
                glClearColor(0.0, 0.0, 0.0, 0.0)
                glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
                self.camera.gotoCameraFrame()
                self.mesh.renderGLIndices()
                pixel = glReadPixels(self.MousePos[0], self.MousePos[1], 1, 1, GL_RGBA, GL_UNSIGNED_BYTE)
                [R, G, B, A] = [int(pixel.encode("hex")[i*2:(i+1)*2], 16) for i in range(4)]
                idx = extractFromRGBA(R, G, B, 0) - 1
                if idx >= 0 and idx < len(self.mesh.vertices):
                    if idx in self.colorChoices:
                        #De-select if it's already selected
                        self.colorCurrentIdx = -1
                        self.colorChoices.pop(idx, None)
                    else:
                        self.colorChoices[idx] = np.array([255, 255, 255])
                        self.colorCurrentIdx = idx
                    self.updateColorChoiceBuffers()
                self.GUISubstate = COLORPICK_WAITING
                self.Refresh()
            
            elif self.GUISubstate == COLORPICK_PICKCOLOR:
                self.drawMeshStandard()
                drawColorPicker(self.size.width, self.size.height, self.colorPickTexID)
                if self.colorCurrentIdx != -1 and self.MousePos[0] < 200 and self.MousePos[1] < 200:
                    pixel = glReadPixels(self.MousePos[0], self.MousePos[1], 1, 1, GL_RGBA, GL_UNSIGNED_BYTE)
                    [R, G, B, A] = [int(pixel.encode("hex")[i*2:(i+1)*2], 16) for i in range(4)]
                    self.colorChoices[self.colorCurrentIdx] = np.array([R, G, B])
                    self.updateColorChoiceBuffers()                    
                self.GUISubstate = COLORPICK_WAITING
                self.Refresh()
                
        self.SwapBuffers()

    def MouseDown(self, evt):
        state = wx.GetMouseState()
        if self.GUIState == STATE_CHOOSELAPLACEVERTICES:
            if state.ShiftDown():
                #Pick vertex for laplacian mesh constraints
                self.GUISubstate = CHOOSELAPLACE_PICKVERTEX
        elif self.GUIState == STATE_CHOOSECOLORVERTICES:
            if state.ShiftDown():
                self.GUISubstate = COLORPICK_PICKVERTEX
            elif state.ControlDown():
                self.GUISubstate = COLORPICK_PICKCOLOR
        x, y = evt.GetPosition()
        self.CaptureMouse()
        self.handleMouseStuff(x, y)
        self.Refresh()

    def MouseMotion(self, evt):
        state = wx.GetMouseState()
        x, y = evt.GetPosition()
        [lastX, lastY] = self.MousePos
        self.handleMouseStuff(x, y)
        dX = self.MousePos[0] - lastX
        dY = self.MousePos[1] - lastY
        if evt.Dragging():
            idx = self.laplaceCurrentIdx
            if self.GUIState == STATE_CHOOSELAPLACEVERTICES and state.ControlDown() and self.laplaceCurrentIdx in self.laplacianConstraints:
                #Move up laplacian mesh constraint based on where the user drags
                #the mouse
                t = self.camera.towards
                u = self.camera.up
                r = np.cross(t, u)
                P0 = self.laplacianConstraints[idx]
                #Construct a plane going through the point which is parallel to the
                #viewing plane
                plane = Plane3D(P0, t)
                #Construct a ray through the pixel where the user is clicking
                tanFOV = math.tan(self.camera.yfov/2)
                scaleX = tanFOV*(self.MousePos[0] - self.size.x/2)/(self.size.x/2)
                scaleY = tanFOV*(self.MousePos[1] - self.size.y/2)/(self.size.y/2)
                V = t + scaleX*r + scaleY*u
                ray = Ray3D(self.camera.eye, V)
                self.laplacianConstraints[idx] = ray.intersectPlane(plane)[1]
            else:
                #Translate/rotate shape
                if evt.MiddleIsDown():
                    self.camera.translate(dX, dY)
                elif evt.RightIsDown():
                    self.camera.zoom(-dY)#Want to zoom in as the mouse goes up
                elif evt.LeftIsDown():
                    self.camera.orbitLeftRight(dX)
                    self.camera.orbitUpDown(dY)
        self.Refresh()

class MeshViewerFrame(wx.Frame):
    (ID_LOADDATASET, ID_SAVEDATASET, ID_SAVEDATASETMETERS, ID_SAVESCREENSHOT, ID_CONNECTEDCOMPONENTS, ID_SPLITFACES, ID_TRUNCATE, ID_FILLHOLES, ID_GEODESICDISTANCES, ID_PRST, ID_INTERPOLATECOLORS, ID_SAVEROTATINGSCREENSOTS, ID_SAVELIGHTINGSCREENSHOTS, ID_SELECTLAPLACEVERTICES, ID_CLEARLAPLACEVERTICES, ID_SOLVEWITHCONSTRAINTS, ID_MEMBRANEWITHCONSTRAINTS, ID_GETHKS, ID_GETHEATFLOW, ID_LAPLACIANSMOOTH, ID_LAPLACIANSHARPEN, ID_MINIMALSURFACE, ID_ESTIMATECURVATURE, ID_GETSPECTRUM, ID_DOLOWPASS, ID_DOHEAT, ID_DOHKS, ID_SELECTCOLORVERTICES, ID_CLEARCOLORVERTICES, ID_INTERPOLATECOLORS, ID_DOFLATTENING, ID_DOUVCOORDS) = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32)
    
    def __init__(self, parent, id, title, pos=DEFAULT_POS, size=DEFAULT_SIZE, style=wx.DEFAULT_FRAME_STYLE, name = 'GLWindow'):
        style = style | wx.NO_FULL_REPAINT_ON_RESIZE
        super(MeshViewerFrame, self).__init__(parent, id, title, pos, size, style, name)
        #Initialize the menu
        self.CreateStatusBar()
        
        self.size = size
        self.pos = pos
        print "MeshViewerFrameSize = %s, pos = %s"%(self.size, self.pos)
        self.glcanvas = MeshViewerCanvas(self)
        
        #####File menu
        filemenu = wx.Menu()
        menuOpenMesh = filemenu.Append(MeshViewerFrame.ID_LOADDATASET, "&Load Mesh","Load a polygon mesh")
        self.Bind(wx.EVT_MENU, self.OnLoadMesh, menuOpenMesh)
        menuSaveMesh = filemenu.Append(MeshViewerFrame.ID_SAVEDATASET, "&Save Mesh", "Save the edited polygon mesh")
        self.Bind(wx.EVT_MENU, self.OnSaveMesh, menuSaveMesh)
        menuSaveScreenshot = filemenu.Append(MeshViewerFrame.ID_SAVESCREENSHOT, "&Save Screenshot", "Save a screenshot of the GL Canvas")
        self.Bind(wx.EVT_MENU, self.OnSaveScreenshot, menuSaveScreenshot)
        
        menuExit = filemenu.Append(wx.ID_EXIT,"E&xit"," Terminate the program")
        self.Bind(wx.EVT_MENU, self.OnExit, menuExit)
        
        #####Laplacian Mesh Menu
        laplacianMenu = wx.Menu()
        menuSelectLaplaceVertices = laplacianMenu.Append(MeshViewerFrame.ID_SELECTLAPLACEVERTICES, "&Select Laplace Vertices", "Select Laplace Vertices")
        self.Bind(wx.EVT_MENU, self.glcanvas.doLaplacianMeshSelectVertices, menuSelectLaplaceVertices)
        
        menuClearLaplaceVertices = laplacianMenu.Append(MeshViewerFrame.ID_CLEARLAPLACEVERTICES, "&Clear vertex selection", "Clear Vertex Selection")
        self.Bind(wx.EVT_MENU, self.glcanvas.clearLaplacianMeshSelection, menuClearLaplaceVertices)
        
        menuSolveWithConstraints = laplacianMenu.Append(MeshViewerFrame.ID_SOLVEWITHCONSTRAINTS, "&Solve with Constraints", "Solve with Constraints")
        self.Bind(wx.EVT_MENU, self.glcanvas.doLaplacianSolveWithConstraints, menuSolveWithConstraints)
        
#        menuEstimateCurvature = laplacianMenu.Append(MeshViewerFrame.ID_ESTIMATECURVATURE, "&Estimate Mean Curvature", "Estimate Mean Curvature")
#        self.Bind(wx.EVT_MENU, self.glcanvas.estimateCurvature, menuEstimateCurvature)
        
        menuLaplacianSmooth = laplacianMenu.Append(MeshViewerFrame.ID_LAPLACIANSMOOTH, "&Laplacian Smooth", "Laplacian Smooth")
        self.Bind(wx.EVT_MENU, self.glcanvas.doLaplacianSmooth, menuLaplacianSmooth)
        
        menuLaplacianSharpen = laplacianMenu.Append(MeshViewerFrame.ID_LAPLACIANSHARPEN, "&Laplacian Sharpen", "Laplacian Sharpen")
        self.Bind(wx.EVT_MENU, self.glcanvas.doLaplacianSharpen, menuLaplacianSharpen)
        
        menuMinimalSurface = laplacianMenu.Append(MeshViewerFrame.ID_MINIMALSURFACE, "&Minimal Surface", "Minimal Surface")
        self.Bind(wx.EVT_MENU, self.glcanvas.doMinimalSurface, menuMinimalSurface)
        
        menuGetSpectrum = laplacianMenu.Append(MeshViewerFrame.ID_GETSPECTRUM, "&Get Spectrum", "Get Spectrum")
        self.Bind(wx.EVT_MENU, self.glcanvas.getSpectrum, menuGetSpectrum)

        menuDoLowpass = laplacianMenu.Append(MeshViewerFrame.ID_DOLOWPASS, "&Do Lowpass", "Do Lowpass")
        self.Bind(wx.EVT_MENU, self.glcanvas.doLowpass, menuDoLowpass)
        
        menuDoHeat = laplacianMenu.Append(MeshViewerFrame.ID_DOHEAT, "&Do Heat Flow Simulation", "Do Heat Flow Simulation")
        self.Bind(wx.EVT_MENU, self.glcanvas.doHeat, menuDoHeat)

        menuDoHKS = laplacianMenu.Append(MeshViewerFrame.ID_DOHKS, "&Compute Heat Kernel Signature", "Do Heat Heat Kernel Signature")
        self.Bind(wx.EVT_MENU, self.glcanvas.doHKS, menuDoHKS)
        
        menuDoFlattening = laplacianMenu.Append(MeshViewerFrame.ID_DOFLATTENING, "&Do Flattening", "Do Flattening")
        self.Bind(wx.EVT_MENU, self.glcanvas.doFlattening, menuDoFlattening)
        
        menuDoUVCoords = laplacianMenu.Append(MeshViewerFrame.ID_DOUVCOORDS, "&Compute UV Coordinates", "Compute UV Coordinates")
        self.Bind(wx.EVT_MENU, self.glcanvas.doUVCoords, menuDoUVCoords) 
        
        #####Color Selection Menu
        colorMenu = wx.Menu()
        menuSelectColorVertices = colorMenu.Append(MeshViewerFrame.ID_SELECTCOLORVERTICES, "&Select Color Vertices", "Select Color Vertices")
        self.Bind(wx.EVT_MENU, self.glcanvas.doSelectColorVertices, menuSelectColorVertices)
        
        menuClearColorVertices = colorMenu.Append(MeshViewerFrame.ID_CLEARCOLORVERTICES, "&Clear color vertex selection", "Clear Color Vertex Selection")
        self.Bind(wx.EVT_MENU, self.glcanvas.clearColorVertexSelection, menuClearColorVertices)
        
        menuInterpolateColors = colorMenu.Append(MeshViewerFrame.ID_INTERPOLATECOLORS, "&Interpolate Colors", "Interpolate Colors")
        self.Bind(wx.EVT_MENU, self.glcanvas.doInterpolateColors, menuInterpolateColors)
        
        # Creating the menubar.
        menuBar = wx.MenuBar()
        menuBar.Append(filemenu,"&File") # Adding the "filemenu" to the MenuBar
        menuBar.Append(laplacianMenu,"&MeshLaplacian") # Adding the "filemenu" to the MenuBar
        menuBar.Append(colorMenu,"&MeshColoring") #Adding the coloring menu
        self.SetMenuBar(menuBar)  # Adding the MenuBar to the Frame content.
        
        self.rightPanel = wx.BoxSizer(wx.VERTICAL)
        
        #Buttons to go to a default view
        viewPanel = wx.BoxSizer(wx.HORIZONTAL)
        topViewButton = wx.Button(self, -1, "Top")
        self.Bind(wx.EVT_BUTTON, self.glcanvas.viewFromTop, topViewButton)
        viewPanel.Add(topViewButton, 0, wx.EXPAND)
        sideViewButton = wx.Button(self, -1, "Side")
        self.Bind(wx.EVT_BUTTON, self.glcanvas.viewFromSide, sideViewButton)
        viewPanel.Add(sideViewButton, 0, wx.EXPAND)
        frontViewButton = wx.Button(self, -1, "Front")
        self.Bind(wx.EVT_BUTTON, self.glcanvas.viewFromFront, frontViewButton)
        viewPanel.Add(frontViewButton, 0, wx.EXPAND)
        self.rightPanel.Add(wx.StaticText(self, label="Views"), 0, wx.EXPAND)
        self.rightPanel.Add(viewPanel, 0, wx.EXPAND)
        
        #Checkboxes for displaying data
        self.displayMeshFacesCheckbox = wx.CheckBox(self, label = "Display Mesh Faces")
        self.displayMeshFacesCheckbox.SetValue(True)
        self.Bind(wx.EVT_CHECKBOX, self.glcanvas.displayMeshFacesCheckbox, self.displayMeshFacesCheckbox)
        self.rightPanel.Add(self.displayMeshFacesCheckbox, 0, wx.EXPAND)
        self.displayMeshEdgesCheckbox = wx.CheckBox(self, label = "Display Mesh Edges")
        self.displayMeshEdgesCheckbox.SetValue(False)
        self.Bind(wx.EVT_CHECKBOX, self.glcanvas.displayMeshEdgesCheckbox, self.displayMeshEdgesCheckbox)
        self.rightPanel.Add(self.displayMeshEdgesCheckbox, 0, wx.EXPAND)
        self.displayMeshVerticesCheckbox = wx.CheckBox(self, label = "Display Mesh Points")
        self.displayMeshVerticesCheckbox.SetValue(True)
        self.Bind(wx.EVT_CHECKBOX, self.glcanvas.displayMeshVerticesCheckbox, self.displayMeshVerticesCheckbox)
        self.rightPanel.Add(self.displayMeshVerticesCheckbox, 0, wx.EXPAND)
        self.displayVertexNormalsCheckbox = wx.CheckBox(self, label = "Display Vertex Normals")
        self.displayVertexNormalsCheckbox.SetValue(False)
        self.Bind(wx.EVT_CHECKBOX, self.glcanvas.displayVertexNormalsCheckbox, self.displayVertexNormalsCheckbox)
        self.rightPanel.Add(self.displayVertexNormalsCheckbox, 0, wx.EXPAND)
        self.displayFaceNormalsCheckbox = wx.CheckBox(self, label = "Display Face Normals")
        self.displayFaceNormalsCheckbox.SetValue(False)
        self.Bind(wx.EVT_CHECKBOX, self.glcanvas.displayFaceNormalsCheckbox, self.displayFaceNormalsCheckbox)
        self.rightPanel.Add(self.displayFaceNormalsCheckbox, 0, wx.EXPAND)
        self.useLightingCheckbox = wx.CheckBox(self, label = "Use Lighting")
        self.useLightingCheckbox.SetValue(True)
        self.Bind(wx.EVT_CHECKBOX, self.glcanvas.useLightingCheckbox, self.useLightingCheckbox)
        self.rightPanel.Add(self.useLightingCheckbox, 0, wx.EXPAND)
        self.useTextureCheckbox = wx.CheckBox(self, label = "Use Texture")
        self.useTextureCheckbox.SetValue(False)
        self.Bind(wx.EVT_CHECKBOX, self.glcanvas.useTextureCheckbox, self.useTextureCheckbox)
        self.rightPanel.Add(self.useTextureCheckbox, 0, wx.EXPAND)

        #Finally add the two main panels to the sizer        
        self.sizer = wx.BoxSizer(wx.HORIZONTAL)
        #cubecanvas = CubeCanvas(self)
        #self.sizer.Add(cubecanvas, 2, wx.EXPAND)
        self.sizer.Add(self.glcanvas, 2, wx.EXPAND)
        self.sizer.Add(self.rightPanel, 0, wx.EXPAND)
        
        self.SetSizer(self.sizer)
        self.Layout()
        self.glcanvas.Show()
    
    def OnLoadMesh(self, evt):
        dlg = wx.FileDialog(self, "Choose a file", ".", "", "OFF files (*.off)|*.off|TOFF files (*.toff)|*.toff|OBJ files (*.obj)|*.obj", wx.OPEN)
        if dlg.ShowModal() == wx.ID_OK:
            filename = dlg.GetFilename()
            dirname = dlg.GetDirectory()
            filepath = os.path.join(dirname, filename)
            print dirname
            self.glcanvas.mesh = PolyMesh()
            print "Loading mesh %s..."%filename
            self.glcanvas.mesh.loadFile(filepath)
            self.glcanvas.meshCentroid = self.glcanvas.mesh.getCentroid()
            self.glcanvas.meshPrincipalAxes = self.glcanvas.mesh.getPrincipalAxes()
            print "Finished loading mesh"
            print self.glcanvas.mesh
            self.glcanvas.initMeshBBox()
            self.glcanvas.Refresh()
        dlg.Destroy()
        return

    def OnSaveMesh(self, evt):
        dlg = wx.FileDialog(self, "Choose a file", ".", "", "*", wx.SAVE)
        if dlg.ShowModal() == wx.ID_OK:
            filename = dlg.GetFilename()
            dirname = dlg.GetDirectory()
            filepath = os.path.join(dirname, filename)
            self.glcanvas.mesh.saveFile(filepath, True)
            self.glcanvas.Refresh()
        dlg.Destroy()
        return     
        
    def OnSaveScreenshot(self, evt):
        dlg = wx.FileDialog(self, "Choose a file", ".", "", "*", wx.SAVE)
        if dlg.ShowModal() == wx.ID_OK:
            filename = dlg.GetFilename()
            dirname = dlg.GetDirectory()
            filepath = os.path.join(dirname, filename)
            saveImageGL(self.glcanvas, filepath)
        dlg.Destroy()
        return

    def OnExit(self, evt):
        self.Close(True)
        return

class MeshViewer(object):
    def __init__(self, filename = None, ts = False, sp = "", ra = 0):
        app = wx.App()
        frame = MeshViewerFrame(None, -1, 'MeshViewer')
        frame.Show(True)
        app.MainLoop()
        app.Destroy()

if __name__ == '__main__':
    viewer = MeshViewer()