Hanoi
VTKExamples/Python/Visualization/Hanoi
Description¶
This is three-dimensional implementation of the Towers of Hanoi.
Here we visualize the operation of the recursive Towers of Hanoi puzzle. In this puzzle there are three pegs. In the initial position there are one or more disks(or pucks) of varying diameter on the pegs. The disks are sorted according to disk diameter, so that the largest disk is on the bottom, followed by the next largest, and so on. The goal of the puzzle is to move the disks from one peg to another, moving the disks one at a time, and never placing a larger disk on top of a smaller disk.
Here we first set up the scene with the table, pegs and pucks. Then we use a function called Hanoi() to begin the recursion. A second function MovePuck() moves the puck from one peg to another.
To give a pleasing visual effect we move the disk in small, user-specified increments, flipping the disc over as it moves from one peg to the next. Option -s controls the user-defined increments. The option -c 2 freezes a disk in mid air moving from one peg to another.
Code¶
Hanoi.py
#!/usr/bin/env python # Translated from Hanoi.cxx. import vtk class GV(object): """ Used to store global variables. """ def __init__(self, numberOfPucks=5, numberOfSteps=5, puckResolution=48, configuration=0): self.numberOfPucks = numberOfPucks self.numberOfSteps = numberOfSteps self.puckResolution = puckResolution self.configuration = configuration self.gotFigure2 = False # Used to bail out of recursion if configuration == 2. self.L = 1.0 # Puck height. self.H = 1.1 * self.numberOfPucks * self.L # Peg height. self.R = 0.5 # Peg radius. self.rMin = 4.0 * self.R # The minimum allowable radius of disks. self.rMax = 12.0 * self.R # The maximum allowable radius of disks self.D = 1.1 * 1.25 * self.rMax # The distance between the pegs. self.numberOfMoves = 0 def update(self, numberOfPucks, numberOfSteps, puckResolution, configuration): self.numberOfPucks = numberOfPucks self.numberOfSteps = numberOfSteps self.puckResolution = puckResolution self.configuration = configuration self.H = 1.1 * self.numberOfPucks * self.L # Peg height. # Globals gv = GV() renWin = vtk.vtkRenderWindow() """ For pegStack we use a list of lists where the sublists correspond to the source, target and helper pegs. Python lists can be used as a stack since they have append() (corresponding to push()) and pop(). """ pegStack = [[], [], []] def hanoi(): colors = vtk.vtkNamedColors() # Create the renderer and render window interactor. ren = vtk.vtkRenderer() renWin.AddRenderer(ren) renWin.SetSize(1200, 750) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) ren.SetBackground(colors.GetColor3d("PapayaWhip")) camera = vtk.vtkCamera() camera.SetPosition(41.0433, 27.9637, 30.442) camera.SetFocalPoint(11.5603, -1.51931, 0.95899) camera.SetClippingRange(18.9599, 91.6042) camera.SetViewUp(0, 1, 0) ren.SetActiveCamera(camera) # Create geometry: table, pegs, and pucks. pegGeometry = vtk.vtkCylinderSource() pegGeometry.SetResolution(8) pegMapper = vtk.vtkPolyDataMapper() pegMapper.SetInputConnection(pegGeometry.GetOutputPort()) puckGeometry = vtk.vtkCylinderSource() puckGeometry.SetResolution(gv.puckResolution) puckMapper = vtk.vtkPolyDataMapper() puckMapper.SetInputConnection(puckGeometry.GetOutputPort()) tableGeometry = vtk.vtkPlaneSource() tableGeometry.SetResolution(10, 10) tableMapper = vtk.vtkPolyDataMapper() tableMapper.SetInputConnection(tableGeometry.GetOutputPort()) # Create the actors: table top, pegs, and pucks # The table table = vtk.vtkActor() ren.AddActor(table) table.SetMapper(tableMapper) # table.GetProperty().SetColor(0.9569, 0.6431, 0.3765) table.GetProperty().SetColor(colors.GetColor3d("SaddleBrown")) table.AddPosition(gv.D, 0, 0) table.SetScale(4 * gv.D, 2 * gv.D, 3 * gv.D) table.RotateX(90) # The pegs (using cylinder geometry). Note that the pegs have to translated # in the y-direction because the cylinder is centered about the origin. gv.H = 1.1 * gv.numberOfPucks * gv.L peg = list() for i in range(0, 3): peg.append(vtk.vtkActor()) ren.AddActor(peg[i]) peg[i].SetMapper(pegMapper) # peg[i].GetProperty().SetColor(1, 1, 1) peg[i].GetProperty().SetColor(colors.GetColor3d("Lavender")) peg[i].AddPosition(i * gv.D, gv.H / 2, 0) peg[i].SetScale(1, gv.H, 1) # The pucks (using cylinder geometry). Always loaded on peg# 0. puck = list() randomSequence = vtk.vtkMinimalStandardRandomSequence() randomSequence.SetSeed(1) for i in range(0, gv.numberOfPucks): puck.append(vtk.vtkActor()) puck[i].SetMapper(puckMapper) color = [0, 0, 0] for j in range(0, 3): color[j] = randomSequence.GetValue() randomSequence.Next() puck[i].GetProperty().SetColor(*color) puck[i].AddPosition(0, i * gv.L + gv.L / 2, 0) scale = gv.rMax - i * (gv.rMax - gv.rMin) / (gv.numberOfPucks - 1) puck[i].SetScale(scale, 1, scale) ren.AddActor(puck[i]) pegStack[0].append(puck[i]) # Reset the camera to view all actors. renWin.Render() renWin.SetWindowName("Towers of Hanoi") if gv.configuration == 3: WriteImage("hanoi0.png", renWin, rgba=False) if gv.configuration != 1: # Begin recursion. Hanoi(gv.numberOfPucks - 1, 0, 2, 1) Hanoi(1, 0, 1, 2) if not gv.gotFigure2: Hanoi(gv.numberOfPucks - 1, 2, 1, 0) renWin.Render() if gv.configuration == 3: WriteImage("hanoi2.png", renWin, rgba=False) # Report output. s = 'Number of moves: {:d}\nPolygons rendered each frame: {:d}\nTotal number of frames: {:d}' print(s.format(gv.numberOfMoves, 3 * 8 + 1 + gv.numberOfPucks * (2 + gv.puckResolution), gv.numberOfMoves * 3 * gv.numberOfSteps)) iren.AddObserver('EndInteractionEvent', OrientationObserver(ren.GetActiveCamera())) # Render the image. iren.Initialize() iren.Start() def main(): maxPucks = 20 if not verify_parameters(maxPucks): return hanoi() def get_program_parameters(): import argparse description = 'Towers of Hanoi. .' epilogue = ''' Where: -p specifies the number of pucks. -s specifies the number of steps. -r specifies the puck resolution. -c specifies configuration. 0 final configuration. 1 initial configuration. 2 intermediate configuration. 3 final configuration and save images Defaults: -p 5 -s 5 -r 48 -c 0 ''' parser = argparse.ArgumentParser(description=description, epilog=epilogue, formatter_class=argparse.RawDescriptionHelpFormatter) parser.add_argument('--numberOfPucks', '-p', default=5, type=int, nargs='?', help='The number of pucks.') parser.add_argument('--numberOfSteps', '-s', default=5, type=int, nargs='?', help='The number of steps.') parser.add_argument('--puckResolution', '-r', default=48, type=int, nargs='?', help='The puck resolution.') parser.add_argument('--configuration', '-c', default=0, type=int, nargs='?', help='The configuration.') args = parser.parse_args() return args.numberOfPucks, args.numberOfSteps, args.puckResolution, args.configuration def verify_parameters(maxPucks): numberOfPucks, numberOfSteps, puckResolution, configuration = get_program_parameters() numberOfPucks = abs(numberOfPucks) numberOfSteps = abs(numberOfSteps) puckResolution = abs(puckResolution) configuration = abs(configuration) check = True if numberOfPucks < 2: print('Please use more pucks!') check = False if numberOfPucks > maxPucks: print('Too many pucks specified! Maximum is', maxPucks) check = False if numberOfSteps < 3: print('Please use more steps!') check = False if configuration > 3: print('0 >= configuration <= 3') check = False if check: gv.update(numberOfPucks, numberOfSteps, puckResolution, configuration) return check def MovePuck(peg1, peg2): """ This routine is responsible for moving pucks from peg1 to peg2. :param peg1: Initial peg. :param peg2: Final peg. :return: """ gv.numberOfMoves += 1 # Get the actor to move movingActor = pegStack[peg1].pop() # Get the distance to move up. distance = (gv.H - (gv.L * (len(pegStack[peg1]) - 1)) + gv.rMax) / gv.numberOfSteps for i in range(0, gv.numberOfSteps): movingActor.AddPosition(0, distance, 0) renWin.Render() # Get the distance to move across distance = (peg2 - peg1) * gv.D / gv.numberOfSteps flipAngle = 180.0 / gv.numberOfSteps for i in range(0, gv.numberOfSteps): movingActor.AddPosition(distance, 0, 0) movingActor.RotateX(flipAngle) renWin.Render() if gv.numberOfMoves == 13 and i == 3: # for making book image if gv.configuration == 3 or gv.configuration == 2: cam = renWin.GetRenderers().GetFirstRenderer().GetActiveCamera() camera1 = vtk.vtkCamera() camera1.SetPosition(54.7263, 41.6467, 44.125) camera1.SetFocalPoint(11.5603, -1.51931, 0.95899) camera1.SetClippingRange(42.4226, 115.659) camera1.SetViewUp(0, 1, 0) renWin.GetRenderers().GetFirstRenderer().SetActiveCamera(camera1) renWin.Render() if gv.configuration == 3: WriteImage("hanoi1.png", renWin, rgba=False) if gv.configuration == 2: gv.gotFigure2 = True break renWin.GetRenderers().GetFirstRenderer().SetActiveCamera(cam) renWin.Render() if gv.gotFigure2: pegStack[peg2].append(movingActor) return # Get the distance to move down. distance = ((gv.L * (len(pegStack[peg2]) - 1)) - gv.H - gv.rMax) / gv.numberOfSteps for i in range(0, gv.numberOfSteps): movingActor.AddPosition(0, distance, 0) renWin.Render() pegStack[peg2].append(movingActor) def Hanoi(n, peg1, peg2, peg3): """ Tower of Hanoi. :param n: Number of disks. :param peg1: Source :param peg2: Target :param peg3: Helper :return: """ # If gotFigure2 is true, we break out of the recursion. if gv.gotFigure2: return if n != 1: Hanoi(n - 1, peg1, peg3, peg2) if gv.gotFigure2: return Hanoi(1, peg1, peg2, peg3) Hanoi(n - 1, peg3, peg2, peg1) else: MovePuck(peg1, peg2) class OrientationObserver(object): def __init__(self, cam): self.cam = cam def __call__(self, caller, ev): # Just do this to demonstrate who called callback and the event that triggered it. print(caller.GetClassName(), "Event Id:", ev) # Now print the camera orientation. CameraOrientation(self.cam) def CameraOrientation(cam): fmt1 = "{:>15s}" fmt2 = "{:9.6g}" print(fmt1.format("Position:"), ', '.join(map(fmt2.format, cam.GetPosition()))) print(fmt1.format("Focal point:"), ', '.join(map(fmt2.format, cam.GetFocalPoint()))) print(fmt1.format("Clipping range:"), ', '.join(map(fmt2.format, cam.GetClippingRange()))) print(fmt1.format("View up:"), ', '.join(map(fmt2.format, cam.GetViewUp()))) print(fmt1.format("Distance:"), fmt2.format(cam.GetDistance())) def WriteImage(fileName, renWin1, rgba=True): """ Write the render window view to an image file. Image types supported are: BMP, JPEG, PNM, PNG, PostScript, TIFF. The default parameters are used for all writers, change as needed. :param fileName: The file name, if no extension then PNG is assumed. :param renWin1: The render window. :param rgba: Used to set the buffer type. :return: """ import os if fileName: # Select the writer to use. path, ext = os.path.splitext(fileName) ext = ext.lower() if not ext: ext = '.png' fileName = fileName + ext if ext == '.bmp': writer = vtk.vtkBMPWriter() elif ext == '.jpg': writer = vtk.vtkJPEGWriter() elif ext == '.pnm': writer = vtk.vtkPNMWriter() elif ext == '.ps': if rgba: rgba = False writer = vtk.vtkPostScriptWriter() elif ext == '.tiff': writer = vtk.vtkTIFFWriter() else: writer = vtk.vtkPNGWriter() windowto_image_filter = vtk.vtkWindowToImageFilter() windowto_image_filter.SetInput(renWin1) windowto_image_filter.SetScale(1) # image quality if rgba: windowto_image_filter.SetInputBufferTypeToRGBA() else: windowto_image_filter.SetInputBufferTypeToRGB() # Read from the front buffer. windowto_image_filter.ReadFrontBufferOff() windowto_image_filter.Update() writer.SetFileName(fileName) writer.SetInputConnection(windowto_image_filter.GetOutputPort()) writer.Write() else: raise RuntimeError('Need a filename.') if __name__ == '__main__': main()