#!/usr/bin/env python
#
# Canyon.py
#
# Author: Ratko Jagodic
# UIC, Feb 2004
#
# Description: Loads a Grand Canyon data file and visualizes
#              it as a height field and contours
#
#############################################################


#
# First we include the VTK Python packages that will make available 
# all of the VTK commands to Python.
#
import vtk
from Tkinter import *
#import vtk.tk.vtkTkRenderWidget

# Make a root window 
root = Tk()  


# Add a vtkTkRenderWidget 
#renderWidget = vtkRenderWindow(root,width=300,height=200) 
#renderWidget.pack(expand='true',fill='both') 

# Get the render window from the widget 
#window = renderWidget.GetRenderWindow() 



###############   GLOBALS   #############
global zoom
global vis
vis = 0
zoom = 1.5
heightFactor = 0.2
c1H = 30
c2H = 100
c3H = 150
c4H = 220

#########################################





#############   DATA FILE    ##############
reader = vtk.vtkImageReader()
reader.SetFileName("E:/Documents and Settings/Ratko Jagodic/My Documents/CLASSES/CS 526 (Computer Graphics II)/Canyon/canyon_elev.raw")
reader.SetFileDimensionality(2)                   # all the slices are in one file 
reader.SetNumberOfScalarComponents(1)   # image is greyscale
reader.SetDataByteOrderToLittleEndian()
reader.SetDataScalarTypeToUnsignedChar()          # 2 bytes per voxel 
reader.SetDataExtent(0, 1023, 0, 511, 0,0)  # 256 x 256 x 120 slices 



###########  COMMON STUFF  ############
shrinkFactor = 1.5
shrink = vtk.vtkImageShrink3D()
shrink.SetShrinkFactors(shrinkFactor, shrinkFactor, 1)
shrink.SetInput(reader.GetOutput())
shrink.AveragingOn()




#############   CONTOURS   #############
contTable = vtk.vtkLookupTable()
contTable.SetHueRange(0.0, 0.667)
contTable.SetSaturationRange(1.0, 1.0)
contTable.SetValueRange(1.0, 0.4)
contTable.SetNumberOfColors(256)
contTable.Build()

contours = vtk.vtkContourFilter()
contours.SetInput(reader.GetOutput())
#contours.SetNumberOfContours(10)
#contours.GenerateValues(10, 0, 256)
contours.SetValue(0, 30)
contours.SetValue(1, 100)
contours.SetValue(2, 150)
contours.SetValue(3, 220)
contours.Update()

cWarp = vtk.vtkWarpScalar()
cWarp.SetInput(contours.GetOutput())
cWarp.XYPlaneOff()    # no z-value so scalars are used for warping
cWarp.UseNormalOn()  # we're providing our own normals to point down
cWarp.SetNormal(0, 0, -1)  # make it point down
cWarp.SetScaleFactor(heightFactor)

cMapper = vtk.vtkPolyDataMapper()
cMapper.SetColorModeToMapScalars()
cMapper.SetLookupTable(contTable)
cMapper.ScalarVisibilityOn()
cMapper.SetScalarRange(0, 256)
#mapper.ScalarVisibilityOff()
cMapper.ImmediateModeRenderingOn()
cMapper.SetInput(cWarp.GetOutput())




############    HEIGHTFIELD    ##############
colorTable = vtk.vtkLookupTable()
colorTable.SetHueRange(0.0, 0.0)
colorTable.SetSaturationRange(0.0, 0.0)
colorTable.SetValueRange(1.0, 0.3)
colorTable.SetNumberOfColors(256)
colorTable.Build()

geom = vtk.vtkImageDataGeometryFilter()
geom.SetInput(shrink.GetOutput())

warp = vtk.vtkWarpScalar()
warp.SetInput(geom.GetOutput())
warp.XYPlaneOff()    # no z-value so scalars are used for warping
warp.UseNormalOn()  # we're providing our own normals to point down
warp.SetNormal(0, 0, -1)  # make it point down
warp.SetScaleFactor(heightFactor)

#compute normals for better looking image
normals = vtk.vtkPolyDataNormals()
normals.SetInput(warp.GetOutput())
normals.SetFeatureAngle(80)
normals.ConsistencyOff()
normals.SplittingOff()

mapper = vtk.vtkPolyDataMapper()
mapper.SetInput(normals.GetOutput())
mapper.SetColorModeToMapScalars()
mapper.SetLookupTable(colorTable)
mapper.ScalarVisibilityOn()
mapper.SetScalarRange(0, 256)
#mapper.ScalarVisibilityOff()
mapper.ImmediateModeRenderingOn()




#############    TEXTURE   #############
texReader = vtk.vtkImageReader()
texReader.SetFileName("E:/Documents and Settings/Ratko Jagodic/My Documents/CLASSES/CS 526 (Computer Graphics II)/Canyon/canyon_rgb.raw")
texReader.SetDataExtent(0,1023, 0,511, 0,0)
texReader.SetDataScalarTypeToUnsignedChar()
texReader.SetNumberOfScalarComponents(3)
texReader.SetDataByteOrderToLittleEndian()

#shrinkFactor = 1.5
shrinkTex = vtk.vtkImageShrink3D()
shrinkTex.SetShrinkFactors(shrinkFactor, shrinkFactor, 1)
shrinkTex.SetInput(texReader.GetOutput())
shrinkTex.AveragingOn()

texLUT = vtk.vtkLookupTable()
texLUT.SetHueRange(0.0, 0.667)
texLUT.SetNumberOfColors(256)
texLUT.SetRange(0, 256)
texLUT.Build()

tex = vtk.vtkTexture()
tex.SetInput(texReader.GetOutput())
tex.InterpolateOn()
#tex.SetLookupTable(texLUT)
#tex.MapColorScalarsThroughLookupTableOn()
#tex.RepeatOff()

colorTexTable = vtk.vtkLookupTable()
colorTexTable.SetHueRange(0.0, 0.667)
colorTexTable.SetSaturationRange(1.0, 1.0)
colorTexTable.SetValueRange(1.0, 0.3)
colorTexTable.SetNumberOfColors(256)
colorTexTable.Build()

geomTex = vtk.vtkImageDataGeometryFilter()
geomTex.SetInput(reader.GetOutput())

warpTex = vtk.vtkWarpScalar()
warpTex.SetInput(geomTex.GetOutput())
warpTex.XYPlaneOff()    # no z-value so scalars are used for warping
warpTex.UseNormalOn()  # we're providing our own normals to point down
warpTex.SetNormal(0, 0, -1)  # make it point down
warpTex.SetScaleFactor(heightFactor)

#compute normals for better looking image
normalsTex = vtk.vtkPolyDataNormals()
normalsTex.SetInput(warpTex.GetOutput())
normalsTex.SetFeatureAngle(80)
normalsTex.ConsistencyOff()
normalsTex.SplittingOff()


mapperTex = vtk.vtkPolyDataMapper()
mapperTex.SetInput(normalsTex.GetOutput())
#mapperTex.SetLookupTable(colorTexTable)#colorTexTable
#mapperTex.ScalarVisibilityOn()
#mapperTex.SetScalarRange(0, 256) #16777216
#mapperTex.SetColorModeToMapScalars()
#mapperTex.SetColorModeToDefault()
mapperTex.ScalarVisibilityOff()
mapperTex.ImmediateModeRenderingOn()




############    COLORMAP    ##############
colorMapTable = vtk.vtkLookupTable()
colorMapTable.SetHueRange(0.36, 0.0)
colorMapTable.SetSaturationRange(1.0, 1.0)
colorMapTable.SetValueRange(0.9, 0.4) #0.8, 0.2
colorMapTable.SetNumberOfColors(256)
colorMapTable.Build()

mapperColor = vtk.vtkPolyDataMapper()
mapperColor.SetInput(normals.GetOutput())
mapperColor.SetColorModeToMapScalars()
#mapperColor.SetColorModeToDefault()
#mapperColor.SetLookupTable(colorMapTable)
#mapperColor.ScalarVisibilityOn()
mapperColor.SetScalarRange(0, 256)
#mapper.ScalarVisibilityOff()
mapperColor.ImmediateModeRenderingOn()



#########    ACTORS   ########
actor = vtk.vtkLODActor()   #Height field
actor.SetNumberOfCloudPoints(100000)
actor.SetMapper(mapper)

cActor = vtk.vtkLODActor()  #Contours
cActor.SetNumberOfCloudPoints(100000)
cActor.SetMapper(cMapper)

texActor = vtk.vtkLODActor()  #Texture
texActor.SetNumberOfCloudPoints(100000)
texActor.SetMapper(mapperTex)
texActor.SetTexture(tex)

actorColor = vtk.vtkLODActor()   #Height field
actorColor.SetNumberOfCloudPoints(100000)
actorColor.SetMapper(mapperColor)




#########   LIGHT, WINDOW, RENDERER   ###########
light = vtk.vtkLight()
light.SetLightTypeToSceneLight()

renderer = vtk.vtkRenderer()
if vis == 0:
    renderer.AddActor( actor )
elif vis == 1:
    renderer.AddActor( cActor )
elif vis == 2:
    renderer.AddActor( texActor )
elif vis == 3:
    renderer.AddActor( actorColor )
    
renderer.GetActiveCamera().Elevation(-30)
renderer.GetActiveCamera().Zoom(zoom)
renderer.GetActiveCamera().SetClippingRange(10, 10000)
renderer.AddLight(light)

window = vtk.vtkRenderWindow()
window.AddRenderer( renderer )
window.SetSize( 850, 700 )
window.SetPosition(170, 0)
window.Render()



#########   USER INTERACTION   ###########
#we need an interactor for rotations
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(window)

#make it a trackball controlling the camera
style = vtk.vtkInteractorStyleTrackballCamera()
iren.SetInteractorStyle(style)


def showContours():
    vis = 1
    renderer.RemoveActor( actor )
    renderer.RemoveActor( texActor )
    renderer.RemoveActor( actorColor )
    renderer.AddActor( cActor )
    window.Render()
    
def showHeightfields():
    vis = 0
    renderer.RemoveActor( cActor )
    renderer.RemoveActor( texActor )
    renderer.RemoveActor( actorColor )
    renderer.AddActor( actor )
    window.Render()

def showTexture():
    vis = 2
    renderer.RemoveActor( actor )
    renderer.RemoveActor( cActor )
    renderer.RemoveActor( actorColor )
    renderer.AddActor( texActor )
    window.Render()
    
def showColormap():
    vis = 3    
    renderer.RemoveActor( texActor )
    renderer.RemoveActor( actor )
    renderer.RemoveActor( cActor )
    renderer.AddActor(actorColor)
    window.Render()
    
def changeHeight(val):
    heightFactor = heightScale.get()
    #print "Height Factor is ", heightFactor
    if vis == 2:
        warpTex.SetScaleFactor(heightFactor)
        warpTex.Update()
    elif vis == 0:
        warp.SetScaleFactor(heightFactor)
        warp.Update()
    else:
        cWarp.SetScaleFactor(heightFactor)
        cWarp.Update()
        
    #window.Render()

def updateHeight():
    window.Render()
    
def c1(val1):
    c1H = c1Scale.get()
    contours.SetValue(0, c1H)
    contours.Update()
def c2(val2):
    c2H = c2Scale.get()
    contours.SetValue(1, c2H)
    contours.Update()
def c3(val3):
    c3H = c3Scale.get()
    contours.SetValue(2, c3H)
    contours.Update()
def c4(val4):
    c4H = c4Scale.get()
    contours.SetValue(3, c4H)
    contours.Update()

    
    
#button = Button(text="Quit",command=quit) 
#button.pack()

inButton = Button(text="Contours",command=showContours) 
inButton.pack(expand='true', fill='x')

outButton = Button(text="Height Field",command=showHeightfields) 
outButton.pack(expand='true', fill='x')

texButton = Button(text="Texture",command=showTexture) 
texButton.pack(expand='true', fill='x')

colorMapButton = Button(text="Colormap",command=showColormap) 
colorMapButton.pack(expand='true', fill='x')

hLabel = Label(text="\n\nChange Height\n_________________\n", foreground="red")
hLabel.pack(expand='true', fill='x')

heightScale = Scale(from_=0, to=1, command=changeHeight, resolution=0.01)
heightScale.pack(expand='true')

cLabel = Label(text="\nChange Contours\n_________________\n", foreground="red")
cLabel.pack(expand='true', fill='x')

c1Scale = Scale(from_=0, to=256, command=c1)
c1Scale.pack(side=LEFT)
c2Scale = Scale(from_=0, to=256, command=c2)
c2Scale.pack(side=LEFT)
c3Scale = Scale(from_=0, to=256, command=c3)
c3Scale.pack(side=LEFT)
c4Scale = Scale(from_=0, to=256, command=c4)
c4Scale.pack(side=LEFT)


#uLabel = Label(text="\n\nUpdate Everything\n_________________\n", foreground="red")
#uLabel.pack()

updateButton = Button(text="Update",command=updateHeight, background="red") 
updateButton.pack(side=BOTTOM)
#start the Tk user interface
root.mainloop()


#start the interaction
iren.Initialize()
iren.Start()