#!/usr/bin/env python

import random

import vtk
import Tkinter
from vtk.tk.vtkTkRenderWindowInteractor import \
     vtkTkRenderWindowInteractor

from vtk.util.misc import vtkGetDataRoot
VTK_DATA_ROOT = vtkGetDataRoot()

class PlaneInteractor:

    def __init__(self ):
        self.last_value = 0

        self.reader = vtk.vtkVolume16Reader()
        self.reader.SetDataDimensions(64, 64)
        self.reader.SetDataByteOrderToLittleEndian()
        self.reader.SetFilePrefix(VTK_DATA_ROOT + "/Data/headsq/quarter")
        self.reader.SetImageRange(1, 93)
        self.reader.SetDataSpacing(3.2, 3.2, 1.5)
        
        #self.reader = vtk.vtkPNGReader()
        #self.reader.SetFilePattern( '/Users/bolstadm/Desktop/s01-SegTiles/s01-seg-tile%02d.png' )
        #self.reader.SetDataExtent(0, 812, 0, 541, 1, 93)
        #self.reader.SetDataSpacing(1, 1, 5)
        #self.reader.SetDataScalarTypeToUnsignedShort()
        #self.reader.UpdateWholeExtent()# Start by loading some data.

        self._grayreader = vtk.vtkImageMapToColors()
        self._grayreader.SetInputConnection(self.reader.GetOutputPort())
        self._lut = vtk.vtkLookupTable()
        self._lut.SetNumberOfColors(13000)
        self._lut.SetTableRange(0, 13000)
        self._lut.Build()
        for i in range(1, 13000):
            r = random.random()
            g = random.random()
            b = random.random()
            color = (r, g, b, 1)
            self._lut.SetTableValue(i, *color)
        self._lut.SetTableValue(0, 0, 0, 0, 1)
        self._grayreader.SetLookupTable(self._lut)
        self._grayreader.UpdateWholeExtent()

        # An outline is shown for context.
        outline = vtk.vtkOutlineFilter()
        outline.SetInputConnection(self._grayreader.GetOutputPort())

        outlineMapper = vtk.vtkPolyDataMapper()
        outlineMapper.SetInputConnection(outline.GetOutputPort())

        outlineActor = vtk.vtkActor()
        outlineActor.SetMapper(outlineMapper)

        # The shared picker enables us to use 3 planes at one time
        # and gets the picking order right
        self.picker = vtk.vtkCellPicker()
        self.picker.SetTolerance(0.005)

        self.planeactor = vtk.vtkImageActor()
        self.planeactor.SetInput( self._grayreader.GetOutput())
        print self.planeactor.GetWholeZMin(), self.planeactor.GetWholeZMax()

        # Create the RenderWindow and Renderer
        self.ren = vtk.vtkRenderer()
        self.renWin = vtk.vtkRenderWindow()
        self.renWin.AddRenderer(self.ren)

        # Add the outline actor to the renderer, set the background color and size
        self.ren.AddActor(outlineActor)
        self.ren.AddActor(self.planeactor)
        self.light = vtk.vtkLightKit()
        self.light.MaintainLuminanceOn()
        self.light.AddLightsToRenderer( self.ren )

        self.renWin.SetSize(600, 600)
        self.ren.SetBackground(0.1, 0.1, 0.2)


    def render( self ):
        # Set the interactor for the widgets
        iact = render_widget.GetRenderWindow().GetInteractor()

        # Create an initial interesting view
        cam1 = self.ren.GetActiveCamera()
        cam1.Elevation(110)
        cam1.SetViewUp(0, 0, -1)
        cam1.Azimuth(45)
        self.ren.ResetCameraClippingRange()

        iact.Initialize()
        #iact.SetPicker( self.picker )
        self.renWin.Render()
        iact.Start()


slice_number = 0

def SetSlice( sl ):
    global plane
    plane.planeactor.SetZSlice(int(sl))
    plane.ren.ResetCameraClippingRange()
    plane.renWin.Render()
    print plane.planeactor.GetZSlice()

plane = PlaneInteractor()

###
# Now actually create the GUI
root = Tkinter.Tk()
root.withdraw()
top = Tkinter.Toplevel(root)

# Define a quit method that exits cleanly.
def quit(obj=root):
    obj.quit()

display_frame = Tkinter.Frame(top)
display_frame.pack(side="top", anchor="n", fill="both", expand="false")

# Buttons
ctrl_buttons = Tkinter.Frame(top)
ctrl_buttons.pack(side="top", anchor="n", fill="both", expand="false")

quit_button = Tkinter.Button(ctrl_buttons, text="Quit", command=quit)

# Create the render widget
renderer_frame = Tkinter.Frame(display_frame)
renderer_frame.pack(padx=3, pady=3,side="left", anchor="n",
            fill="both", expand="false")

render_widget = vtkTkRenderWindowInteractor(renderer_frame,
                        rw=plane.renWin, width=600,
                        height=600)
for i in (render_widget, display_frame):
    i.pack(side="top", anchor="n",fill="both", expand="false")

# Add a slice scale to browse the current slice stack
slice_value = Tkinter.IntVar()
slice_value.set(plane.planeactor.GetZSlice())

xMin, xMax, yMin, yMax, zMin, zMax = plane._grayreader.GetOutput().GetWholeExtent()

slice = Tkinter.Scale(top, from_=zMin, to=zMax, orient="horizontal",
              command=SetSlice, variable=slice_value,
              label="Slice")
slice.pack(fill="x", expand="false")

# Done with the GUI. 
###

# Render it
render_widget.Render()

plane.render()

# Start Tkinter event loop
root.mainloop()