def __init__(self, embryo,  parent=None):
		
		#super(vtkSimVisualizerCutter, self).__init__(embryo,parent)
		vtkSimVisualizer.__init__(self,embryo,parent=parent)
		
		# Check if 3D embryo
		if self.embryo.geometry.dim==2:
			printWarning("vtkSimVisualizerCutter does only work and make sense for 3D geometries. Will not initialize cutter and fall back tostandad vtkSimVisualizer.")
			return
		
		self.vtkWidgetCut,self.renCut,self.irenCut=self.initVTKWidget(self.frame)
		
		# Plane used for cutting
		self.plane = vtk.vtkPlane()
		
		# Cutter
		self.cutter = vtk.vtkCutter()
		
		# Plane widget
		self.initPlaneWidget()
		
		# Add Layout
		self.layout.addWidget(self.vtkWidgetCut,1,2)
	
		# Run cut mesh once
		self.CutMesh()
	
		self.irenCut.Initialize()

 def __init__(self):
     """Setup the pipeline.
     """
     self.reader = vtkSTLReader()
     
     self.cutter = vtkCutter()
     self.cutter.SetInputConnection(self.reader.GetOutputPort())
     
     self.regionPicker = vtkPolyDataConnectivityFilter()
     self.regionPicker.SetInputConnection(self.cutter.GetOutputPort())
     self.regionPicker.SetExtractionModeToClosestPointRegion()
     
     self.scaler = vtkTransformPolyDataFilter()
     self.scaler.SetInputConnection(self.regionPicker.GetOutputPort())
     
     self.GetFileName = self.reader.GetFileName
     self.SetFileName = self.reader.SetFileName
     
     self.GetOutputPort = self.scaler.GetOutputPort
     self.GetOutput = self.scaler.GetOutput
     self.Update = self.scaler.Update
     
     self.iolet = None
     self.fileUnitLength = None
     
     return

    def create_cut_acto_plane(self,xpos,ypos,zpos,plane_id):
        #vtk plane
        plane=vtk.vtkPlane()
        plane.SetOrigin(xpos,ypos,zpos)

        if plane_id==0:
            plane.SetNormal(1,0,0)
        if plane_id==1:
            plane.SetNormal(0,1,0)
        if plane_id==2:
            plane.SetNormal(0.0,0.0,1)

        #create cutter
        cutter=vtk.vtkCutter()
        cutter.SetCutFunction(plane)
        cutter.SetInputConnection(self.dti_reader.GetOutputPort())
        cutter.Update()


        #probe filter for the cutting plane
        probe_filter=vtk.vtkProbeFilter()
        probe_filter.SetInputConnection(cutter.GetOutputPort())
        probe_filter.SetSourceConnection(self.dti_reader.GetOutputPort())


        self.plane1=plane

        return probe_filter

	def InitVTKMethods(self):
		"""Initializes the VTK methods to be used."""
		self.colortable=ColorTableSource()
		self._plane=vtkPlane()
		self._cutter=vtkCutter()
		self._mapper=vtkDataSetMapper()
		self.actor=vtkLODActor()

def ImplicitFunctionVtuCut(inputVtu, implicitFunction):
  """
  Perform a cut of a vtu. Cutting as in ClipCow.py vtkCutter example of vtk
  documentation 5.0.4, and Fluidity test case lock_exchange_tet.xml results
  variable.
  """
  
  # The cutter
  cutter = vtk.vtkCutter()
  cutter.SetCutFunction(implicitFunction)
  if vtk.vtkVersion.GetVTKMajorVersion() <= 5:
    cutter.SetInput(inputVtu.ugrid)
  else:
    cutter.SetInputData(inputVtu.ugrid)
  # Cut
  cutter.Update()
  cutUPoly = cutter.GetOutput()
  # Construct output  
  result = vtu()
  result.ugrid = PolyDataToUnstructuredGrid(cutUPoly)
  
  if result.ugrid.GetNumberOfPoints() == 0:
    debug.deprint("Warning: Cut vtu contains no nodes")
  
  return result

    def get(self):
        resultado = {}
        imageData = reader.get("IMAGE", self.subj, format="VTK", name=self.get_argument("type", None), space="world")

        plane=vtk.vtkPlane()
        if (self.get_argument("plane", None) == "x"):
            plane.SetNormal(1,0,0)
            plane.SetOrigin(float(self.get_argument("pos", None)),0,0)
        if (self.get_argument("plane", None) == "y"):
            plane.SetNormal(0,1,0)
            plane.SetOrigin(0,float(self.get_argument("pos", None)),0)
        if (self.get_argument("plane", None) == "z"):
            plane.SetNormal(0,0,1)
            plane.SetOrigin(0,0,float(self.get_argument("pos", None)))
            
        planeCut = vtk.vtkCutter()
        planeCut.SetInputData(imageData)
        planeCut.SetCutFunction(plane)
        planeCut.Update()
                
        resultado['subject'] = self.subj
        resultado['type'] = 'image'
        resultado['plane'] = self.get_argument("plane", None)    
        resultado['pos'] = self.get_argument("pos", None)    
        resultado['bounds'] = planeCut.GetOutput().GetBounds()
        resultado['dimensions'] = imageData.GetDimensions()
        resultado['scalars'] = numpy_support.vtk_to_numpy(planeCut.GetOutput().GetPointData().GetScalars()).tolist()

        self.set_header("Content-Type","application/json")
        self.write(json.dumps(resultado, separators=(',',':')))

def cut(cube, normal):
    plane=vtk.vtkPlane()
    plane.SetOrigin(cube.GetCenter())
    plane.SetNormal(*normal)
     
    #create cutter
    cutter=vtk.vtkCutter()
    cutter.SetCutFunction(plane)
    cutter.SetInputConnection(cube.GetOutputPort())
    cutter.Update()
    cutterMapper=vtk.vtkPolyDataMapper()
    cutterMapper.SetInputConnection( cutter.GetOutputPort())
     
    #create plane actor
    planeActor=vtk.vtkActor()
    planeActor.GetProperty().SetColor(1.0,1,0)
    planeActor.GetProperty().SetLineWidth(2)
    planeActor.SetMapper(cutterMapper)
     
    #create renderers and add actors of plane and cube
    ren.AddActor(planeActor)
   
    ret = [] 
    points = cutter.GetOutput().GetPoints()
    for i in range(points.GetNumberOfPoints()):
        point = points.GetPoint(i)
        ret.append( point )
    return ret 

 def addPlaneCutter(self, i):
     #take record of the plane weight 
     planeWeightTextValue = self.planeWeightText[i].text()
     self.planeWtInt[i] = planeWeightTextValue.toFloat()
     self.ren.RemoveActor(self.planeActor)
     plane=vtk.vtkPlane()
     plane.SetOrigin(float(self.firstPlanePtValueRecord[i][0]),float(self.firstPlanePtValueRecord[i][1]), float(self.firstPlanePtValueRecord[i][2]) )
     a = np.array([self.secondPlanePtValueRecord[i][0]-self.firstPlanePtValueRecord[i][0], self.secondPlanePtValueRecord[i][1]-self.firstPlanePtValueRecord[i][1], self.secondPlanePtValueRecord[i][2]-self.firstPlanePtValueRecord[i][2]])
     b = np.array([self.thirdPlanePtValueRecord[i][0]-self.firstPlanePtValueRecord[i][0], self.thirdPlanePtValueRecord[i][1]-self.firstPlanePtValueRecord[i][1],self.thirdPlanePtValueRecord[i][2]-self.firstPlanePtValueRecord[i][2]])
     self.planeOrigin[i] = self.firstPlanePtValueRecord[i]
     self.planeNormal[i] = np.cross(a, b)
     self.planeNormal[i] = self.planeNormal[i] / np.linalg.norm(self.planeNormal[i])
     plane.SetNormal(self.planeNormal[i])
                 
     #create cutter
     cutter=vtk.vtkCutter()
     cutter.SetCutFunction(plane)
     cutter.SetInputConnection(self.append.GetOutputPort())
     cutter.Update()
     cutterMapper=vtk.vtkPolyDataMapper()
     cutterMapper.SetInputConnection(cutter.GetOutputPort())
                 
     
     self.planeActor.GetProperty().SetColor(1.0,1,0)
     self.planeActor.GetProperty().SetLineWidth(2)
     self.planeActor.SetMapper(cutterMapper)
                 
     self.ren.AddActor(self.planeActor)

    def __init__ (self, mod_m): 
        debug ("In VectorCutPlane::__init__ ()")
        Common.state.busy ()
        Base.Objects.CutPlaneModule.__init__ (self, mod_m)
        self.cut = vtk.vtkCutter ()
        self.glyph2d_src = vtk.vtkGlyphSource2D ()
        self.cone = vtk.vtkConeSource ()
        self.arrow = vtk.vtkArrowSource ()
        self.glyph_src = self.cone
        self.glyph3d = vtk.vtkGlyph3D ()
        self.mapper = self.map = vtk.vtkPolyDataMapper ()
        self.actor = self.act = vtk.vtkActor ()
        # used to orient the cone properly
        self.glph_trfm = vtk.vtkTransformFilter ()
        self.glph_trfm.SetTransform (vtk.vtkTransform ())
        self.data_out = self.mod_m.GetOutput ()

        # Point of glyph that is attached -- -1 is tail, 0 is center,
        # 1 is head.
        self.glyph_pos = -1 
        self.scale = 1.0
        self.color_mode = 2 #2 is vector, 1 is scalar, -1 none
        self._initialize ()
        self._gui_init ()
        self.renwin.Render ()
        Common.state.idle ()

    def addContourObject(self, contourObject, prop3D):
        """Activate contouring for the contourObject.  The contourObject
        is usually a tdObject and specifically a vtkPolyData.  We also
        need the prop3D that represents this polydata in the 3d scene.
        """
        if self._contourObjectsDict.has_key(contourObject):
            # we already have this, thanks
            return

        try:
            contourable = contourObject.IsA('vtkPolyData')
        except:
            contourable = False

        if contourable:
            # we need a cutter to calculate the contours and then a stripper
            # to string them all together
            cutter = vtk.vtkCutter()
            plane = vtk.vtkPlane()
            cutter.SetCutFunction(plane)
            trfm = vtk.vtkTransform()
            trfm.SetMatrix(prop3D.GetMatrix())
            trfmFilter = vtk.vtkTransformPolyDataFilter()
            trfmFilter.SetTransform(trfm)
            trfmFilter.SetInput(contourObject)
            cutter.SetInput(trfmFilter.GetOutput())
            stripper = vtk.vtkStripper()
            stripper.SetInput(cutter.GetOutput())
            
            #
            #tubef = vtk.vtkTubeFilter()
            #tubef.SetNumberOfSides(12)
            #tubef.SetRadius(0.5)
            #tubef.SetInput(stripper.GetOutput())

            # and create the overlay at least for the 3d renderer
            mapper = vtk.vtkPolyDataMapper()
            mapper.SetInput(stripper.GetOutput())
            mapper.ScalarVisibilityOff()
            actor = vtk.vtkActor()
            actor.SetMapper(mapper)
            c = self.sliceDirections.slice3dVWR._tdObjects.getObjectColour(
                contourObject)
            actor.GetProperty().SetColor(c)
            actor.GetProperty().SetInterpolationToFlat()

            # add it to the renderer
            self.sliceDirections.slice3dVWR._threedRenderer.AddActor(actor)
            
            # add all necessary metadata to our dict
            contourDict = {'contourObject' : contourObject,
                           'contourObjectProp' : prop3D,
                           'trfmFilter' : trfmFilter,
                           'cutter' : cutter,
                           'tdActor' : actor}
                           
            self._contourObjectsDict[contourObject] = contourDict

            # now sync the bugger
            self.syncContourToObject(contourObject)

    def initialize (self):
        debug ("In CutPlane::initialize ()")
        self.plane = vtk.vtkPlane ()
        self.fil = vtk.vtkCutter ()
        out = self.prev_fil.GetOutput()
        self.fil.SetInput (out)
        self.fil.SetCutFunction (self.plane)

        self.center = out.GetCenter ()
        self.plane.SetOrigin (self.center)
        self.plane.SetNormal (0.0, 0.0, 1.0)

        self.step_var = Tkinter.DoubleVar ()
        self.n_step_var = Tkinter.IntVar ()
        self.resoln_var = Tkinter.DoubleVar ()
        self.resoln_var.set (1.0)
        self.slider = []
        self.set_def_step_size ()
        self.step_var.set (self.step_size)
        self.n_step_var.set (10)        
        self.slider_pos = 0
        self._auto_sweep_init ()
        self.sweep_step.set (1)

        self.fil.Update ()

 def AddDataSet(self, dataset, property):
     doit = True
     if not dataset:
         doit = False
     
     if self.HasDataSet(dataset):
         doit = False
     
     imagedata = vtk.vtkImageData.SafeDownCast(dataset)
     if imagedata:
         self.SetImage(imagedata)
     else:
         if not self.Image:
             doit=False
     
         if doit:
             matrix = vtk.vtkMatrix4x4()
             for i in range(3):
                 for j in range(3):
                     matrix.SetElement(i,j,self.ImageReslice.GetResliceAxes().GetElement(j,i))
                 matrix.SetElement(i, 3, 0)
             matrix.SetElement(3, 3, 1)
             
             cutter = vtk.vtkCutter()
             cutter.SetCutFunction(self.DataSetCutPlane)
             
             # Very strangely in some cases (ex : landmarks)
             # the cutter increments the RefCount of the input dataset by 2
             # making some memory leek...
             # I could not manage to know what is wrong here
             cutter.SetInput(dataset)
             cutter.Update()
             
             if not cutter.GetOutput():
                 print "Unable to cut this dataset..."
                 del matrix
                 del cutter
                 return None
             
             mapper = vtk.vtkPolyDataMapper()
             mapper.SetInput(cutter.GetOutput())
             
             actor = vtk.vtkActor()
             actor.SetUseMatrix(matrix)
             actor.SetMapper(mapper)
             if property:
                 actor.SetProperty(property)
             actor.PickableOff()  
             self.AddActor(actor)
             self.DataSetList.append(dataset)
             self.DataSetActorList.append(actor)
             
             self.ResetAndRestablishZoomAndCamera()
             del actor
             del mapper
             del matrix
             del cutter
     return self.GetDataSetActor(dataset)

def cutdataset(dataset, point, normal):
    cutplane = vtk.vtkPlane()
    cutplane.SetOrigin(point)
    cutplane.SetNormal(normal)
    cutter = vtk.vtkCutter()
    cutter.SetInputData(dataset)
    cutter.SetCutFunction(cutplane)
    cutter.Update()
    return cutter.GetOutput()

def slicedataset(dataset, point, normal):
    """Slice through a vtkDataSet object with a plane defined by point and
    normal."""
    cutplane = vtk.vtkPlane()
    cutplane.SetOrigin(point)
    cutplane.SetNormal(normal)
    cutter = vtk.vtkCutter()
    cutter.SetInput(dataset)
    cutter.SetCutFunction(cutplane)
    cutter.Update()
    return cutter.GetOutput()

    def _UpdateIntersections(self):
        if self._Planes is None:
            return
        if self._Cube is None:
            return

        self._Cutters = []
        for plane in self._Planes:
            cutter = vtk.vtkCutter()
            cutter.SetCutFunction(plane.GetPlaneEquation())
            cutter.SetInput(self._Cube.GetOutput())
            self._Cutters.append(cutter)

 def __init__(self, module_manager):
     SimpleVTKClassModuleBase.__init__(
         self,
         module_manager,
         vtk.vtkCutter(),
         "Processing.",
         ("vtkDataSet",),
         ("vtkPolyData",),
         replaceDoc=True,
         inputFunctions=None,
         outputFunctions=None,
     )

    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.vtkWidget.GetRenderWindow().AddRenderer(self.ren)
        self.iren = self.vtkWidget.GetRenderWindow().GetInteractor()
         
        #Create a sphere
        sphere = vtk.vtkSphereSource()
        sphere.SetRadius(50)
        sphere.SetThetaResolution(100)
        sphere.SetPhiResolution(100)
         
        plane = vtk.vtkPlane()
        plane.SetOrigin(20, 0, 0)
        plane.SetNormal(1, 0, 0)
         
        #create cutter
        cutter = vtk.vtkCutter()
        cutter.SetCutFunction(plane)
        cutter.SetInputConnection(sphere.GetOutputPort())
        cutter.Update()
         
        cutStrips = vtk.vtkStripper()
        cutStrips.SetInputConnection(cutter.GetOutputPort())
        cutStrips.Update()
        cutPoly = vtk.vtkPolyData()
        cutPoly.SetPoints((cutStrips.GetOutput()).GetPoints())
        cutPoly.SetPolys((cutStrips.GetOutput()).GetLines())
         
        cutMapper = vtk.vtkPolyDataMapper()
        cutMapper.SetInput(cutPoly)
        #cutMapper.SetInputConnection(cutter.GetOutputPort())
         
        cutActor = vtk.vtkActor()
        cutActor.GetProperty().SetColor(1, 1, 0)
        cutActor.GetProperty().SetEdgeColor(0, 1, 0)
         
        cutActor.GetProperty().SetLineWidth(2)
        cutActor.GetProperty().EdgeVisibilityOn()
        cutActor.SetMapper(cutMapper)

        #create renderers and add actors of plane and cube
        self.ren.AddActor(cutActor)

        self.ren.ResetCamera()
        self._initialized = False

 def _createCutter(self):
     logging.debug("In MultiSliceContour::createCutter()")
     self._cutters = []
     self._planeCutters = []
     for slice in self._scene.slice:
         cutter = vtk.vtkCutter()
         plane = vtk.vtkPlane()
         plane.SetOrigin(slice.plane.GetOrigin())
         plane.SetNormal(slice.plane.GetNormal())
         cutter.SetCutFunction(plane)
         cutter.GenerateCutScalarsOn()
         self._planeCutters.append(plane)
         self._cutters.append(cutter)

    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.vtkWidget.GetRenderWindow().AddRenderer(self.ren)
        self.iren = self.vtkWidget.GetRenderWindow().GetInteractor()

        #Create a cube
        cube=vtk.vtkCubeSource()
        cube.SetXLength(40)
        cube.SetYLength(30)
        cube.SetZLength(20)
        cubeMapper=vtk.vtkPolyDataMapper()
        cubeMapper.SetInputConnection(cube.GetOutputPort())
         
        #create a plane to cut,here it cuts in the XZ direction (xz normal=(1,0,0);XY =(0,0,1),YZ =(0,1,0)
        plane=vtk.vtkPlane()
        plane.SetOrigin(10,0,0)
        plane.SetNormal(1,0,0)
         
        #create cutter
        cutter=vtk.vtkCutter()
        cutter.SetCutFunction(plane)
        cutter.SetInputConnection(cube.GetOutputPort())
        cutter.Update()
        cutterMapper=vtk.vtkPolyDataMapper()
        cutterMapper.SetInputConnection( cutter.GetOutputPort())
         
        #create plane actor
        planeActor=vtk.vtkActor()
        planeActor.GetProperty().SetColor(1.0,1,0)
        planeActor.GetProperty().SetLineWidth(2)
        planeActor.SetMapper(cutterMapper)
         
        #create cube actor
        cubeActor=vtk.vtkActor()
        cubeActor.GetProperty().SetColor(0.5,1,0.5)
        cubeActor.GetProperty().SetOpacity(0.5)
        cubeActor.SetMapper(cubeMapper)
         
        #create renderers and add actors of plane and cube
        self.ren.AddActor(planeActor)
        self.ren.AddActor(cubeActor) 

        self.ren.ResetCamera()
        self._initialized = False

def cutplanes(data, origin, normal):
    # create cutting plane
    plane = createplane(origin,normal)
    # create cutter
    cutter = vtk.vtkCutter()
    cutter.SetCutFunction(plane)
    cutter.SetInputData(data)
    cutter.Update()
    #print cutter
    cutslice = cutter.GetOutput()
    npoints = cutslice.GetNumberOfPoints()
    ncells = cutslice.GetNumberOfCells()
    #print cutslice
    return cutslice, npoints, ncells