def __init__(self, volume, level=None):
        self._surface_algorithm = None
        self._renderer = None
        self._actor = None
        self._mapper = None
        self._volume_array = None

        self._float_array = _vtk.vtkFloatArray()
        self._image_data = _vtk.vtkImageData()
        self._image_data.GetPointData().SetScalars(self._float_array)
        self._setup_data(_numpy.float32(volume))

        self._surface_algorithm = _vtk.vtkMarchingCubes()
        self._surface_algorithm.SetInputData(self._image_data)
        self._surface_algorithm.ComputeNormalsOn()

        if level is not None:
            try:
                self.set_multiple_levels(iter(level))
            except TypeError:
                self.set_level(0, level)

        self._mapper = _vtk.vtkPolyDataMapper()
        self._mapper.SetInputConnection(self._surface_algorithm.GetOutputPort())
        self._mapper.ScalarVisibilityOn() # new
        self._actor = _vtk.vtkActor()
        self._actor.SetMapper(self._mapper)

    def __init__(self, module_manager):
        # initialise our base class
        ModuleBase.__init__(self, module_manager)
        # initialise any mixins we might have
        NoConfigModuleMixin.__init__(self)


        # we'll be playing around with some vtk objects, this could
        # be anything
        self._thresh = vtk.vtkThresholdPoints()
        # this is wacked syntax!
        self._thresh.ThresholdByUpper(1)
        self._reconstructionFilter = vtk.vtkSurfaceReconstructionFilter()
        self._reconstructionFilter.SetInput(self._thresh.GetOutput())
        self._mc = vtk.vtkMarchingCubes()
        self._mc.SetInput(self._reconstructionFilter.GetOutput())
        self._mc.SetValue(0, 0.0)

        module_utils.setup_vtk_object_progress(self, self._thresh,
                                           'Extracting points...')
        module_utils.setup_vtk_object_progress(self, self._reconstructionFilter,
                                           'Reconstructing...')
        module_utils.setup_vtk_object_progress(self, self._mc,
                                           'Extracting surface...')

        self._iObj = self._thresh
        self._oObj = self._mc
        
        self._viewFrame = self._createViewFrame({'threshold' :
                                                 self._thresh,
                                                 'reconstructionFilter' :
                                                 self._reconstructionFilter,
                                                 'marchingCubes' :
                                                 self._mc})

    def Execute(self):

        if self.Image == None:
            self.PrintError('Error: No Image.')

        extent = self.Image.GetExtent()
        translateExtent = vtk.vtkImageTranslateExtent()
        translateExtent.SetInputData(self.Image)
        translateExtent.SetTranslation(-extent[0],-extent[2],-extent[4])
        translateExtent.Update()

        if (self.ArrayName != ''):
            translateExtent.GetOutput().GetPointData().SetActiveScalars(self.ArrayName)

        marchingCubes = vtk.vtkMarchingCubes()
        marchingCubes.SetInputConnection(translateExtent.GetOutputPort())
        marchingCubes.SetValue(0,self.Level)
        marchingCubes.Update()

        self.Surface = marchingCubes.GetOutput()

        if self.Connectivity == 1:
            connectivityFilter = vtk.vtkPolyDataConnectivityFilter()
            connectivityFilter.SetInputData(self.Surface)
            connectivityFilter.SetExtractionModeToLargestRegion()
            connectivityFilter.Update()
            self.Surface = connectivityFilter.GetOutput()

    def __init__(self, renderer, interactor):

        self.connect = ConnectFilter()
        self.deci = DecimateFilter()
        self.marchingCubes = vtk.vtkMarchingCubes()

        self.prog = ProgressBarDialog(
            title='Rendering surface %s' % self.label,
            parent=None,
            msg='Marching cubes ....',
            size=(300,40),
                                 )
        def start(o, event):
            self.prog.show()
            while gtk.events_pending(): gtk.main_iteration()


        def progress(o, event):
            val = o.GetProgress()
            self.prog.bar.set_fraction(val)            
            while gtk.events_pending(): gtk.main_iteration()
            
        def end(o, event):
            self.prog.hide()
            while gtk.events_pending(): gtk.main_iteration()

        self.marchingCubes.AddObserver('StartEvent', start)
        self.marchingCubes.AddObserver('ProgressEvent', progress)
        self.marchingCubes.AddObserver('EndEvent', end)
        self.renderer = renderer
        self.interactor = interactor
        self.isoActor = None
        
        self.update_pipeline()

    def __init__(self, brain_data, isoval=34):
        # Setup Surface Rendering

        # Gaussian smoothing of surface rendering for aesthetics
        # Adds significant delay to rendering
        self.cortexSmoother = vtk.vtkImageGaussianSmooth()
        self.cortexSmoother.SetDimensionality(3)
        self.cortexSmoother.SetRadiusFactors(0.5, 0.5, 0.5)
        self.cortexSmoother.SetInput(brain_data.GetOutput())

        # Apply a marching cubes algorithm to extract surface contour with
        # isovalue of 30 (can change to adjust proper rendering of tissue
        self.cortexExtractor = vtk.vtkMarchingCubes()
        self.cortexExtractor.SetInput(self.cortexSmoother.GetOutput())
        self.cortexExtractor.SetValue(0, isoval)
        self.cortexExtractor.ComputeNormalsOn()

        # Map/Paint the polydata associated with the surface rendering
        self.cortexMapper = vtk.vtkPolyDataMapper()
        self.cortexMapper.SetInput(self.cortexExtractor.GetOutput())
        self.cortexMapper.ScalarVisibilityOff()

        # Color the cortex (RGB)
        self.cortexProperty = vtk.vtkProperty()
        self.cortexProperty.SetColor(1, 1, 1)
        self.cortexProperty.SetOpacity(1);

        # Set the actor to adhere to mapped surface and inherit properties
        self.SetMapper(self.cortexMapper)
        self.SetProperty(self.cortexProperty)
        self.cortexExtractor.Update()

    def initialize(self):
        #self._vtk_widget.Initialize()
        super(SurfaceViewer, self).initialize()
        
        self._surface_algorithm = vtk.vtkMarchingCubes()
        if vtk_tools.VTK_VERSION >= 6:
            self._surface_algorithm.SetInputData(self._image_data)
        else:
            self._surface_algorithm.SetInput(self._image_data)
        self._surface_algorithm.ComputeNormalsOn()
        self._surface_algorithm.SetValue(0, self._surface_level)

        mapper = vtk.vtkPolyDataMapper()
        mapper.SetInputConnection(self._surface_algorithm.GetOutputPort())
        mapper.ScalarVisibilityOff()
        self._actor = vtk.vtkActor()
        self._actor.GetProperty().SetColor(0., 1., 0.)
        self._actor.SetMapper(mapper)
        self._renderer.AddViewProp(self._actor)
        self._renderer.Render()
        self._vtk_widget.Render()
        
        self._level_slider = QtGui.QSlider(QtCore.Qt.Horizontal)
        self._level_slider.setMaximum(self._SLIDER_MAXIMUM)
        self._level_slider.valueChanged.connect(self._slider_changed)
        self._level_slider.setValue(self._INITIAL_SLIDER_POSITION)
        
        self._layout.addWidget(self._level_slider)
        self._vtk_widget.Render()

    def __init__(self, module_manager, contourFilterText):

        # call parent constructor
        ModuleBase.__init__(self, module_manager)

        self._contourFilterText = contourFilterText
        if contourFilterText == 'marchingCubes':
            self._contourFilter = vtk.vtkMarchingCubes()
        else: # contourFilter == 'contourFilter'
            self._contourFilter = vtk.vtkContourFilter()

        module_utils.setup_vtk_object_progress(self, self._contourFilter,
                                           'Extracting iso-surface')

        # now setup some defaults before our sync
        self._config.isoValue = 128;

        self._viewFrame = None
        self._createViewFrame()

        # transfer these defaults to the logic
        self.config_to_logic()

        # then make sure they come all the way back up via self._config
        self.logic_to_config()
        self.config_to_view()

 def __init__(self, module_manager):
     SimpleVTKClassModuleBase.__init__(
         self, module_manager,
         vtk.vtkMarchingCubes(), 'Processing.',
         ('vtkImageData',), ('vtkPolyData',),
         replaceDoc=True,
         inputFunctions=None, outputFunctions=None)

def main(argv):
  if len(argv) < 2:
    print "usage:",argv[0]," data.vtk"
    exit(1)
  data_fn = argv[1]
  reader = vtk.vtkStructuredPointsReader()
  reader.SetFileName(data_fn)
  reader.Update()
  data = reader.GetOutput()
  skin = vtk.vtkMarchingCubes()
  skin.ComputeNormalsOn()
  skin.ComputeGradientsOn()
  skin.SetValue(0, rgb[0][0])
  skin.SetInput(data)
  skin_mapper = vtk.vtkPolyDataMapper()
  skin_mapper.SetInputConnection(skin.GetOutputPort())
  skin_mapper.ScalarVisibilityOff()
  skin_actor = vtk.vtkActor()
  skin_property = vtk.vtkProperty()
  skin_property.SetColor(rgb[0][1], rgb[0][2], rgb[0][3])
  skin_property.SetOpacity(opacity[0][1])
  skin_actor.SetProperty(skin_property)
  skin_actor.SetMapper(skin_mapper)
  bone = vtk.vtkMarchingCubes()
  bone.ComputeNormalsOn()
  bone.ComputeGradientsOn()
  bone.SetValue(0, rgb[1][0])
  bone.SetInput(data)
  bone_mapper = vtk.vtkPolyDataMapper()
  bone_mapper.SetInputConnection(bone.GetOutputPort())
  bone_mapper.ScalarVisibilityOff()
  bone_actor = vtk.vtkActor()
  bone_actor.GetProperty().SetColor(rgb[1][1], rgb[1][2], rgb[1][3])
  bone_actor.GetProperty().SetOpacity(opacity[1][1])
  bone_actor.SetMapper(bone_mapper)
  renderer = vtk.vtkRenderer()
  renderWin = vtk.vtkRenderWindow()
  renderWin.AddRenderer(renderer)
  renderInteractor = vtk.vtkRenderWindowInteractor()
  renderInteractor.SetRenderWindow(renderWin)
  renderer.AddActor(skin_actor)
  #renderer.AddActor(bone_actor)
  renderer.SetBackground(0,0,0)
  renderWin.SetSize(400, 400)
  renderInteractor.Initialize()
  renderWin.Render()
  renderInteractor.Start()

	def createIsoSurface(self,configuration):
		marchingCube = vtk.vtkMarchingCubes()
		marchingCube.SetInputConnection(self.reader.GetOutputPort())
		marchingCube.SetValue(0,configuration.getIsoValue())
		marchingCube.ComputeNormalsOn()
		self.outputPortForMapper = marchingCube.GetOutputPort()
		self.createMapper()
		self.createActor()
		self.modifyActorIso(configuration)
		self.finalizePipeline()

    def __init__(self, parent = None):
        super(VTKFrame, self).__init__(parent)

        self.vtkWidget = QVTKRenderWindowInteractor(self)
        vl = QtGui.QVBoxLayout(self)
        vl.addWidget(self.vtkWidget)
        vl.setContentsMargins(0, 0, 0, 0)
 
        self.ren = vtk.vtkRenderer()
        self.ren.SetBackground(0.1, 0.2, 0.4)
        self.vtkWidget.GetRenderWindow().AddRenderer(self.ren)
        self.iren = self.vtkWidget.GetRenderWindow().GetInteractor()

        sphereSource = vtk.vtkSphereSource()
        sphereSource.SetPhiResolution(20)
        sphereSource.SetThetaResolution(20)
        sphereSource.Update()

        bounds = [1, 1, 1, 1, 1, 1]
        sphereSource.GetOutput().GetBounds(bounds)
        for i in range(0, 6, 2):
            range_ = bounds[i+1] - bounds[i]
            bounds[i] = bounds[i] - 0.1 * range_
            bounds[i+1] = bounds[i+1] + 0.1 * range_

        voxelModeller = vtk.vtkVoxelModeller()
        voxelModeller.SetSampleDimensions(50, 50, 50)
        voxelModeller.SetModelBounds(bounds)
        voxelModeller.SetScalarTypeToFloat()
        voxelModeller.SetMaximumDistance(0.1)

        voxelModeller.SetInputConnection(sphereSource.GetOutputPort())
        voxelModeller.Update()

        volume = vtk.vtkImageData()
        volume.DeepCopy(voxelModeller.GetOutput())

        surface = vtk.vtkMarchingCubes()
        surface.SetInput(volume)
        surface.SetValue(0, 0.5)
 
        # Create a mapper
        mapper = vtk.vtkPolyDataMapper()
        mapper.SetInputConnection(surface.GetOutputPort())
 
        # Create an actor
        actor = vtk.vtkActor()
        actor.SetMapper(mapper)
 
        self.ren.AddActor(actor)
        self.ren.ResetCamera()

        self._initialized = False

def vtk_iso(vol, iso_thresh=1):
    im_data = vol.tostring()
    img = vtk.vtkImageImport()
    img.CopyImportVoidPointer(im_data, len(im_data))
    img.SetDataScalarType(vtk.VTK_UNSIGNED_SHORT)
    img.SetNumberOfScalarComponents(1)
    img.SetDataExtent(0, vol.shape[2]-1, 0, vol.shape[1]-1, 0, vol.shape[0]-1)
    img.SetWholeExtent(0, vol.shape[2]-1, 0, vol.shape[1]-1, 0, vol.shape[0]-1)
    iso = vtk.vtkMarchingCubes()
    iso.SetInput(img.GetOutput())
    iso.SetValue(0, iso_thresh)
    return iso,img

	def __init__(self, inputs = (1,1)):
		"""
		Initialization
		"""
		self.defaultLower = 0
		self.defaultUpper = 255
		lib.ProcessingFilter.ProcessingFilter.__init__(self,(1,1))
		self.contour = vtk.vtkMarchingCubes()
		self.decimate = vtk.vtkDecimatePro()
		self.descs = {"Simplify": "Simplify surface", "IsoValue":"Iso-surface value", 
		"PreserveTopology":"PreserveTopology"}
		self.filterDesc = "Creates iso-surface as polygons\nInput: Binary image (Grayscale image)\nOutput: Surface mesh";

 def adjust_contour(self, volume, contourValue, mapper):
     """Adjust or create an isocontour using the Marching Cubes surface at the given 
     value using the given mapper
     """
 	self._view_frame.SetStatusText("Calculating new volumerender...")
 	contour = vtk.vtkMarchingCubes()
 	contour.SetValue(0,contourValue)
 	contour.SetInput(volume)
 	mapper.SetInput(contour.GetOutput())
 	mapper.Update()
 	self.render()
 	self._view_frame.SetStatusText("Calculated new volumerender")

    def DisplayLevelSetSurface(self,levelSets,value=0.0):
      
        marchingCubes = vtk.vtkMarchingCubes()
        marchingCubes.SetInputData(levelSets)
        marchingCubes.SetValue(0,value)
        marchingCubes.Update()

        self.OutputText('Displaying.\n')

        self.SurfaceViewer.Surface = marchingCubes.GetOutput()
        self.SurfaceViewer.Display = 0
        self.SurfaceViewer.Opacity = 0.5
        self.SurfaceViewer.BuildView()

    def marchingCubes(self, image, ijkToRasMatrix, threshold):


        transformIJKtoRAS = vtk.vtkTransform()
        transformIJKtoRAS.SetMatrix(ijkToRasMatrix)

        marchingCubes = vtk.vtkMarchingCubes()
        marchingCubes.SetInputData(image)
        marchingCubes.SetValue(0, threshold)
        marchingCubes.ComputeScalarsOn()
        marchingCubes.ComputeGradientsOn()
        marchingCubes.ComputeNormalsOn()
        marchingCubes.ReleaseDataFlagOn()
        marchingCubes.Update()


        if transformIJKtoRAS.GetMatrix().Determinant() < 0:
            reverser = vtk.vtkReverseSense()
            reverser.SetInputData(marchingCubes.GetOutput())
            reverser.ReverseNormalsOn()
            reverser.ReleaseDataFlagOn()
            reverser.Update()
            correctedOutput = reverser.GetOutput()
        else:
            correctedOutput = marchingCubes.GetOutput()

        transformer = vtk.vtkTransformPolyDataFilter()
        transformer.SetInputData(correctedOutput)
        transformer.SetTransform(transformIJKtoRAS)
        transformer.ReleaseDataFlagOn()
        transformer.Update()

        normals = vtk.vtkPolyDataNormals()
        normals.ComputePointNormalsOn()
        normals.SetInputData(transformer.GetOutput())
        normals.SetFeatureAngle(60)
        normals.SetSplitting(1)
        normals.ReleaseDataFlagOn()
        normals.Update()

        stripper = vtk.vtkStripper()
        stripper.SetInputData(normals.GetOutput())
        stripper.ReleaseDataFlagOff()
        stripper.Update()
        stripper.GetOutput()

        result = vtk.vtkPolyData()
        result.DeepCopy(stripper.GetOutput())

        return result

    def DisplayLevelSetSurface(self,levelSets,value=0.0):
      
        marchingCubes = vtk.vtkMarchingCubes()
        marchingCubes.SetInput(levelSets)
        marchingCubes.SetValue(0,value)
        marchingCubes.Update()

        self.OutputText('Displaying.\n')
  
        self.SurfaceViewer.Surface = marchingCubes.GetOutput()
        if self.SurfaceViewer.Surface.GetSource():
            self.SurfaceViewer.Surface.GetSource().UnRegisterAllOutputs()
        self.SurfaceViewer.Display = 1
        self.SurfaceViewer.Opacity = 0.5
        self.SurfaceViewer.BuildView()

    def test_vtk_exceptions(self):
        """Test if VTK has been patched with our VTK error to Python exception
        patch.
        """

        import vtk
        a = vtk.vtkXMLImageDataReader()
        a.SetFileName('blata22 hello')
        b = vtk.vtkMarchingCubes()
        b.SetInput(a.GetOutput())

        try:
            b.Update()
        except RuntimeError, e:
            self.failUnless(str(e).startswith('ERROR'))

    def _setup_surface(self):
        """Create the isosurface object, mapper and actor"""
        self._surface_level = INIT_SURFACE_LEVEL
        self._surface_algorithm = vtk.vtkMarchingCubes()
        self._surface_algorithm.SetInputData(self._volume)
        self._surface_algorithm.ComputeNormalsOn()
        self._surface_algorithm.SetValue(0, self._surface_level)

        mapper = vtk.vtkPolyDataMapper()
        mapper.SetInputConnection(self._surface_algorithm.GetOutputPort())
        mapper.ScalarVisibilityOff()
        self._surface_actor = vtk.vtkActor()
        self._surface_actor.GetProperty().SetColor(self._color[0], self._color[1], self._color[2])
        self._surface_actor.SetMapper(mapper)

        self._renderer.AddViewProp(self._surface_actor)

	def calculateFrontAndRear(self, reader, maxPush, minPush):
		"""
		Method to calculate front and rear of objects in the track
		Image parameter must be vtkImageData
		"""
		spacing = []
		for i in range(len(self.voxelSize)):
			spacing.append(self.voxelSize[i] / self.voxelSize[0])
		
		for tp in range(self.mintp, self.maxtp + 1):
			label = self.values[tp]
			com1 = self.points[tp]

			if tp == self.maxtp: # Use latest direction
				for i in range(len(direction)):
					direction[i] *= -1.0
			else:
				com2 = self.points[tp+1]
				direction = []
				for i in range(len(com1)):
					direction.append(com2[i] - com1[i])

			# Polygon data
			image = reader.getDataSet(tp)
			objThreshold = vtk.vtkImageThreshold()
			objThreshold.SetInput(image)
			objThreshold.SetOutputScalarTypeToUnsignedChar()
			objThreshold.SetInValue(255)
			objThreshold.SetOutValue(0)
			objThreshold.ThresholdBetween(label,label)
			marchingCubes = vtk.vtkMarchingCubes()
			marchingCubes.SetInput(objThreshold.GetOutput())
			marchingCubes.SetValue(0, 255)
			marchingCubes.Update()
			polydata = marchingCubes.GetOutput()
			polydata.Update()

			front = self.locateOutmostPoint(polydata, com1, direction, maxPush, minPush)
			for i in range(len(direction)):
				direction[i] *= -1.0
			rear = self.locateOutmostPoint(polydata, com1, direction, maxPush, minPush)
			for i in range(len(front)):
				front[i] /= spacing[i]
				rear[i] /= spacing[i]
			
			self.fronts[tp] = tuple(front)
			self.rears[tp] = tuple(rear)