def get_cylinder(upper, height, radius,
                 direction,
                 resolution=10):

    src = vtk.vtkCylinderSource()
    src.SetCenter((0, height/2, 0))
    src.SetHeight(height + radius/2.0)
    src.SetRadius(radius)
    src.SetResolution(resolution)

    rot1 = vtk.vtkTransform()
    fi = nm.arccos(direction[1])

    rot1.RotateWXYZ(-nm.rad2deg(fi), 0.0, 0.0, 1.0)
    u = nm.abs(nm.sin(fi))
    rot2 = vtk.vtkTransform()
    if u > 1.0e-6:

        # sometimes d[0]/u little bit is over 1
        d0_over_u = direction[0] / u
        if d0_over_u > 1:
            psi = 0
        elif d0_over_u < -1:
            psi = 2 * nm.pi
        else:
            psi = nm.arccos(direction[0] / u)

        logger.debug('d0 '+str(direction[0])+'  u '+str(u)+' psi '+str(psi))
        if direction[2] < 0:
            psi = 2 * nm.pi - psi

        rot2.RotateWXYZ(-nm.rad2deg(psi), 0.0, 1.0, 0.0)

    tl = vtk.vtkTransform()
    tl.Translate(upper)

    tr1a = vtk.vtkTransformFilter()
    tr1a.SetInput(src.GetOutput())
    tr1a.SetTransform(rot1)

    tr1b = vtk.vtkTransformFilter()
    tr1b.SetInput(tr1a.GetOutput())
    tr1b.SetTransform(rot2)

    tr2 = vtk.vtkTransformFilter()
    tr2.SetInput(tr1b.GetOutput())
    tr2.SetTransform(tl)

    tr2.Update()

    return tr2.GetOutput()

 def wrapOpImp(self):
     transformFilter = vtk.vtkTransformFilter();
     transformFilter.SetTransform(self.getTransform());
     transformFilter.SetInputData(self.data);
     transformFilter.Update();
     result = transformFilter.GetOutput();
     return result;

    def attach_stl(self, fname, scale=None):
        """Load a given STL file into a vtkPolyData object"""

        reader = vtk.vtkSTLReader()
        reader.SetFileName(fname)
        reader.Update() # polydata

        if scale is not None:
            trans = vtk.vtkTransform()
            trans.Scale(scale)

            filt = vtk.vtkTransformFilter()

            if vtk.VTK_MAJOR_VERSION <= 5:
                filt.SetInputConnection(reader.GetOutputPort)
            else:
                filt.SetInputConnection(reader.GetOutputPort())
                   
            filt.SetTransform(trans)

        mapper = vtk.vtkPolyDataMapper()

        if vtk.VTK_MAJOR_VERSION <= 5:
           mapper.SetInput(filt.GetOutput())
        else:
           mapper.SetInputConnection(filt.GetOutputPort())

        actor = vtk.vtkActor()
        actor.SetMapper(mapper)

        self._ren.AddActor(actor)

    def __init__(self, profile):
        """Clip the STL and set attributes on the SWIG-proxied C++ 
        GeometryGenerator object.
        """
        self.profile = profile
        self.generator = Generation.PolyDataGenerator()
        self._SetCommonGeneratorProperties()
        
        self.generator.SetSeedPointWorking(profile.SeedPoint.x / profile.VoxelSize,
                                           profile.SeedPoint.y / profile.VoxelSize,
                                           profile.SeedPoint.z / profile.VoxelSize)

        # This will create the pipeline for the clipped surface
        clipper = Clipper(profile)

        # Scale by the voxel size
        trans = vtkTransform()
        scale = 1. / profile.VoxelSize
        trans.Scale(scale, scale, scale)
        
        transformer = vtkTransformFilter()
        transformer.SetTransform(trans)
        transformer.SetInputConnection(clipper.ClippedSurfaceSource.GetOutputPort())
        
        # Uncomment this an insert the output path to debug pipeline construction
        # write = StageWriter('/path/to/stage/output/directory').WriteOutput
        # for alg in getpipeline(transformer):
        #    write(alg)

        transformer.Update()
        self.ClippedSurface = transformer.GetOutput()
        self.generator.SetClippedSurface(self.ClippedSurface)
        
        return

 def __init__(self, module_manager):
     SimpleVTKClassModuleBase.__init__(
         self, module_manager,
         vtk.vtkTransformFilter(), 'Processing.',
         ('vtkPointSet',), ('vtkPointSet',),
         replaceDoc=True,
         inputFunctions=None, outputFunctions=None)

    def get_slice(self, image, rotation):
        """Generate a polydata object of the provided image rotated by the
        provided rotation."""

        rotation_degrees = rotation.copy()
        rotation_degrees[0] = 2.*numpy.arccos(rotation[0])*180./numpy.pi
        transformation = vtk.vtkTransform()
        transformation.RotateWXYZ(rotation_degrees[0], rotation_degrees[1],
                                  rotation_degrees[2], rotation_degrees[3])
        transform_filter = vtk.vtkTransformFilter()
        input_poly_data = vtk.vtkPolyData()
        input_poly_data.DeepCopy(self._template_poly_data)
        # This deep copy stuff is needed since transform returns a
        # pointer to the same object but transformed (i think) but
        # it should be checked really.
        #input_poly_data = self._template_poly_data.
        #transform_filter.SetInputData(self._template_poly_data)
        transform_filter.SetInputData(input_poly_data)
        transform_filter.SetTransform(transformation)
        transform_filter.Update()
        this_poly_data = transform_filter.GetOutput()

        scalars = this_poly_data.GetPointData().GetScalars()
        for i in range(self._side):
            for j in range(self._side):
                # point_coord = this_poly_data.GetPoint(self._side*i + j)
                #if point_coord[0] > 0.:
                scalars.SetTuple1(i*self._side+j, image[i, j])
                #scalars.SetTuple1(i*self._side+j, image[j, i])
                # else:
                #     #polys.GetData().SetTuple4(i*self._side+j, 0., 0., 0., 0.)
                #     scalars.SetTuple1(i*self._side+j, nan)
        this_poly_data.Modified()
        return this_poly_data

    def Execute(self):

        if (self.Mesh == None):
            self.PrintError('Error: no Mesh.')

        if not self.Matrix4x4:
            self.Matrix4x4 = vtk.vtkMatrix4x4()
            if self.MatrixCoefficients != []:
                self.PrintLog('Setting up transform matrix using specified coefficients')
                self.Matrix4x4.DeepCopy(self.MatrixCoefficients)
            elif self.Translation != [0.0,0.0,0.0] or self.Rotation != [0.0,0.0,0.0] or self.Scaling != [1.0,1.0,1.0]:
                self.PrintLog('Setting up transform matrix using specified translation, rotation and/or scaling')
                transform = vtk.vtkTransform()
                transform.RotateX(self.Rotation[0])
                transform.RotateY(self.Rotation[1])
                transform.RotateZ(self.Rotation[2])                       
                transform.Translate(self.Translation[0], self.Translation[1], self.Translation[2])
                transform.Scale(self.Scaling[0], self.Scaling[1], self.Scaling[2])
                self.Matrix4x4.DeepCopy(transform.GetMatrix())

        if self.InvertMatrix:
            self.Matrix4x4.Invert()

        transform = vtk.vtkMatrixToLinearTransform()
        transform.SetInput(self.Matrix4x4)

        transformFilter = vtk.vtkTransformFilter()
        transformFilter.SetInputData(self.Mesh)
        transformFilter.SetTransform(transform)
        transformFilter.Update()

        self.Mesh = transformFilter.GetOutput()

def CreateTorus(point1, point2, axe):
	"""
	Creates a torus that has point1 as center point2 defines
	a point on the torus.
	"""
	direction = map(lambda x, y: x - y, point2, point1)
	length = math.sqrt(sum(map(lambda x: x ** 2, direction)))

	torus = vtkParametricTorus()
	torus.SetRingRadius(length / 1.5)
	torus.SetCrossSectionRadius(length / 30.0)

	torusSource = vtkParametricFunctionSource()
	torusSource.SetParametricFunction(torus)
	torusSource.SetScalarModeToPhase()
	torusSource.Update()

	transform = vtkTransform()
	if axe == 0:
		transform.RotateY(90)
	elif axe == 1:
		transform.RotateX(90)

	transformFilter = vtkTransformFilter()
	transformFilter.SetInputConnection(torusSource.GetOutputPort())
	transformFilter.SetTransform(transform)
	transformFilter.Update()

	torusMapper = vtkPolyDataMapper()
	torusMapper.SetInputConnection(transformFilter.GetOutputPort())

	torusActor = vtkActor()
	torusActor.SetMapper(torusMapper)

	return torusActor, transformFilter.GetOutput()

 def WriteVTSXMLVolumeFile(self):
     if (self.OutputFileName == ''):
         self.PrintError('Error: no OutputFileName.')
     self.PrintLog('Writing VTS XML grid file.')
     if self.ApplyTransform == 0:
         origin = self.Image.GetOrigin()
         spacing = self.Image.GetSpacing()
         matrix = vtk.vtkMatrix4x4()
         matrix.DeepCopy((1/spacing[0], 0, 0, - origin[0]/spacing[0], 
                      0, 1/spacing[1], 0, - origin[1]/spacing[1],
                      0, 0, 1/spacing[2], - origin[2]/spacing[2],
                      0, 0, 0, 1)) #LPI convention with correct origin and spacing 
     else:
         if self.RasToIjkMatrixCoefficients == None:
             self.PrintError('Error: no RasToIjkMatrixCoefficients.')
         matrix = vtk.vtkMatrix4x4()
         matrix.DeepCopy(self.RasToIjkMatrixCoefficients)
     trans = vtk.vtkTransform()
     trans.SetMatrix(matrix)
     trans_filt = vtk.vtkTransformFilter()
     trans_filt.SetTransform(trans)
     trans_filt.SetInputData(self.Image)
     trans_filt.Update()
     writer = vtk.vtkXMLStructuredGridWriter()
     writer.SetInputConnection(trans_filt.GetOutputPort())
     writer.SetFileName(self.OutputFileName)
     writer.Write()

 def __init__ (self, mod_m): 
     debug ("In VelocityVector::__init__ ()")
     Common.state.busy ()
     Base.Objects.Module.__init__ (self, mod_m)
     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 TransformFilter(self, currentElement):
     transFilter = vtk.vtkTransformFilter()
     # Datatype(s) I need for input:  Algorithm, LinearTransform
     AlgorithmElement = ''
     TransformElement = ''
     for childElement in currentElement.getchildren():
         if childElement.tag in vtkTypes['Algorithm']:
             AlgorithmElement = childElement
         if childElement.tag in vtkTypes['LinearTransform']:
             TransformElement = childElement
     if AlgorithmElement != '':
         dataset = self.namesToFunctions[AlgorithmElement.tag](AlgorithmElement)
         try:
             transFilter.SetInputConnection(dataset.GetOutputPort())
         except:
             self.logger.error('  .. <TransformFilter> failed to SetInputConnection')
     else:
         self.logger.error('  .. <TransformFilter> needs an Algorithm-type childElement')
     if TransformElement != '':
         transform = self.namesToFunctions[TransformElement.tag](TransformElement)
         try:
             transFilter.SetTransform(transform)
         except:
             self.logger.error('  .. <TransformFilter> failed to SetTransform')
     else:
         self.logger.error('<TransformFilter> needs an Transform-type childElement')
     return transFilter

def surfacescaling(polydata, scalefactor=1.0):
    """Scale a vtkPolyData object."""
    transform = vtk.vtkTransform()
    transform.Scale(scalefactor, scalefactor, scalefactor)
    transformFilter = vtk.vtkTransformFilter()
    transformFilter.SetInput(polydata)
    transformFilter.SetTransform(transform)
    transformFilter.Update()
    return transformFilter.GetOutput()

def surfacetranslation(polydata, translation=[0.0, 0.0, 0.0]):
    """Translate a vtkPolyData object."""
    transform = vtk.vtkTransform()
    transform.Translate(translation)
    transformFilter = vtk.vtkTransformFilter()
    transformFilter.SetInput(polydata)
    transformFilter.SetTransform(transform)
    transformFilter.Update()
    return transformFilter.GetOutput()

    def Execute(self):

        if (self.Mesh == None):
            self.PrintError('Error: no Mesh.')

        transform = vtk.vtkTransform()
        transform.Scale(self.ScaleFactor,self.ScaleFactor,self.ScaleFactor)

        transformFilter = vtk.vtkTransformFilter()
        transformFilter.SetInputData(self.Mesh)
        transformFilter.SetTransform(transform)
        transformFilter.Update()

        self.Mesh = transformFilter.GetOutput()

 def addToScene(self, msource, **kwargs):
   import vtk
   vsource = msource
   if 'translate' in kwargs:
       tf = vtk.vtkTransformFilter()
       tf.SetTransform(vtk.vtkTransform())
       delta = kwargs['translate']
       tf.GetTransform().Translate(delta[0], delta[1], delta[2])
       tf.SetInputConnection(msource.GetOutputPort())
       vsource = tf
   ac = vtk.vtkActor()
   mp = vtk.vtkCompositePolyDataMapper()
   ac.SetMapper(mp)
   mp.SetInputConnection(vsource.GetOutputPort())
   self.renderer.AddActor(ac)

    def Execute(self):

        if (self.Mesh == None):
            self.PrintError('Error: no Mesh.')

        transform = vtk.vtkTransform()
        transform.Scale(self.ScaleFactor,self.ScaleFactor,self.ScaleFactor)

        transformFilter = vtk.vtkTransformFilter()
        transformFilter.SetInput(self.Mesh)
        transformFilter.SetTransform(transform)
        transformFilter.Update()

        self.Mesh = transformFilter.GetOutput()

        if self.Mesh.GetSource():
            self.Mesh.GetSource().UnRegisterAllOutputs()

 def __init__( self, desiredPointSize=0.5, maxNumPoints=1e6 ):
     self.maxNumPoints = maxNumPoints
     self.vtkPolyData = vtk.vtkPolyData()
     self.vtkTransformFilter = vtk.vtkTransformFilter()
     self.vtkTransform = vtk.vtkTransform()
     self.vtkTransformFilter.SetTransform( self.vtkTransform )
     self.vtkTransformFilter.SetInput( self.vtkPolyData )
     self.clearPoints()
     mapper = vtk.vtkPolyDataMapper()
     mapper. SetInput( self.vtkTransformFilter.GetOutput() )
     mapper.SetColorModeToDefault()
     mapper.SetScalarRange( 0.0, 1.0 )
     mapper.SetScalarVisibility(1)
     self.vtkActor = vtk.vtkActor()
     self.vtkActor.SetMapper(mapper)
     property = self.vtkActor.GetProperty()
     property.SetPointSize(desiredPointSize)

    def __init__(self, profile):
        """Clip the STL and set attributes on the SWIG-proxied C++
        GeometryGenerator object.
        """
        GeometryGenerator.__init__(self)
        self._profile = profile
        self.generator = Generation.PolyDataGenerator()
        self._SetCommonGeneratorProperties()
        self.generator.SetSeedPointWorking(
            profile.SeedPoint.x / profile.VoxelSize,
            profile.SeedPoint.y / profile.VoxelSize,
            profile.SeedPoint.z / profile.VoxelSize)

        # This will create the pipeline for the clipped surface
        clipper = Clipper(profile)

        # Scale by the voxel size
        trans = vtkTransform()
        scale = 1. / profile.VoxelSize
        trans.Scale(scale, scale, scale)

        transformer = vtkTransformFilter()
        transformer.SetTransform(trans)
        transformer.SetInputConnection(
            clipper.ClippedSurfaceSource.GetOutputPort())

        # Uncomment this an insert the output path to debug pipeline construction
        # write = StageWriter('/Users/rupert/working/compare/aneurysm').WriteOutput
        # i = 0
        # for alg in getpipeline(transformer):
        #     print i
        #     i += 1
        #     print alg
        #     write(alg)

        transformer.Update()
        self.ClippedSurface = transformer.GetOutput()
        self.generator.SetClippedSurface(self.ClippedSurface)
        
        originWorking, nSites = self._ComputeOriginWorking()
        self.generator.SetOriginWorking(*(float(x) for x in originWorking))
        self.generator.SetSiteCounts(*(int(x) for x in nSites))
        self.OriginMetres = Vector(originWorking * self.VoxelSizeMetres) 
        return

    def initialize (self, valid_coord):        
        """ Initializes the seed given an array of valid co-ordinate
        directions. [x-axis, y-axis, z_axis] is the format.  For
        instance if x-axis == 0 then the data is along the YZ plane.
        This method is responsible for actually creating the seed. """

        debug ("In SeedManager::initialize ()")
        assert len (valid_coord) == 3
        self.dim = reduce (lambda x, y: x+y, valid_coord)
        if self.dim == 3:
            self.seed = vtk.vtkPointSource ()
        else:
            self.seed = vtk.vtkDiskSource ()
            self.seed.SetRadialResolution (1)
            self.seed.SetInnerRadius (0.0)
            self.transform = vtk.vtkTransformFilter ()
            self.transform.SetTransform (vtk.vtkTransform ())
            self.transform.SetInput (self.seed.GetOutput ())
            self.orient_2d (valid_coord)

 def __init__(self, body_fixed=True):
     self.body_fixed = body_fixed
     # vtk objects for creating 3D scene
     self.vtkrenderer = vtk.vtkRenderer()
     self.vtkrenderer.SetBackground(1, 1, 1)
     self.vtkrender_window = vtk.vtkRenderWindow()
     self.vtkrender_window.AddRenderer(self.vtkrenderer)
     self.vtkrender_window.SetSize(self.window_size)
     self.vtkrender_window_interactor = vtk.vtkRenderWindowInteractor()
     self.vtkrender_window_interactor.SetRenderWindow(self.vtkrender_window)
     self.camera = vtk.vtkCamera()
     self.camera.SetPosition([p*self.scale_factor for p in self.camera_pos]);
     self.camera.SetFocalPoint(0, 0, 0);
     self.camera.SetViewUp(self.camera_up);
     self.vtkrenderer.SetActiveCamera(self.camera);
     
     self.vtkvrml_exporter = vtk.vtkVRMLExporter()
     # vtk objects for reading, and rendering object parts
     self.vtkreader = {}
     self.vtkpolydata = {}
     self.vtkmapper = {}
     self.vtktransform = {}
     self.vtkfilter = {}
     # read each part from its stl file
     for part in self.parts:
         self.vtkreader[part] = vtk.vtkSTLReader()
         self.vtkreader[part].SetFileName(self.models_folder + part + '.stl')
         self.vtktransform[part] = vtk.vtkTransform()
         self.vtktransform[part].Scale(self.scale_factor, self.scale_factor, self.scale_factor)
         self.vtkfilter[part] = vtk.vtkTransformFilter()
         self.vtkfilter[part].SetInput(self.vtkreader[part].GetOutput())
         self.vtkfilter[part].SetTransform(self.vtktransform[part])
         self.vtkpolydata[part] = self.vtkfilter[part].GetOutput()
         self.vtkmapper[part] = vtk.vtkPolyDataMapper()
         self.vtkmapper[part].SetInput(self.vtkpolydata[part])
     if self.body_fixed:
         # actor for body part (every object has a part named body at origin)
         self.vtkbodyactor = vtk.vtkActor()
         self.vtkbodyactor.SetMapper(self.vtkmapper['Body'])
         self.vtkbodyactor.SetPosition(0, 0, 0)
         
     self.graspit_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
     self.graspit_socket.connect((self.graspit_tcp_ip, self.graspit_tcp_port))