示例#1
1
    def __draw_sample_as_cylinder(self,sample,color,warning_color):
        a = self.__cylinder_actors.get(sample)
        if a is not None:
            a.SetVisibility(1)
            return
        p1 = sample.coil_center
        p2 = sample.sphere_intersection
        p3 = p1+(p2-p1)*1.2  # an extra 20% to guarantee it goes into the sphere
        #height = self.COIL_HEIGHT*1.2
        height = self.COIL_HEIGHT*500
        source = vtk.vtkCylinderSource()
        source.SetCenter(0,0,0)
        #source.SetRadius(self.SAMPLE_RADIUS)
        source.SetRadius(2)
        source.SetHeight(height)
        source.SetResolution(8)

        trans = vtk.vtkTransform()
        trans.Identity()

        v1 = p1-p2
        v1 /= np.linalg.norm(v1)

        v2 = (0,1,0)
        vp = np.cross(v2,v1)
        angle = np.arcsin(np.linalg.norm(vp))
        angle_deg = 180*angle/np.pi

        trans.Translate(p3)
        trans.RotateWXYZ(angle_deg,vp)
        trans.Translate((0,height/2,0))

        trans_filter = vtk.vtkTransformPolyDataFilter()
        trans_filter.SetInputConnection(source.GetOutputPort())
        trans_filter.SetTransform(trans)

        mapper = vtk.vtkPolyDataMapper()
        mapper.SetInputConnection(trans_filter.GetOutputPort())

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

        self.ren.AddActor(actor)
        self.__cylinder_actors[sample]=actor

        prop = actor.GetProperty()
        if sample.timing_error > 1:
            if warning_color is None:
                warning_color = self.SAMPLE_CYLINDER_WARNING_COLOR
            prop.SetColor(warning_color)
        else:
            if color is None:
                color = self.SAMPLE_CYLINDER_COLOR
            prop.SetColor(color)
        info = vtk.vtkInformation()
        info.Set(vtk.vtkShadowMapBakerPass.RECEIVER(),0)
        info.Set(vtk.vtkShadowMapBakerPass.OCCLUDER(),0)
        #prop.SetAmbient(0.8)
        actor.SetPropertyKeys(info)
示例#2
0
def Merge5 ():
    reader = vtk.vtkPolyDataReader()
    reader.SetFileName('test10.vtk')

    reader2 = vtk.vtkPolyDataReader()
    reader2.SetFileName('test12.vtk')

    reader3 = vtk.vtkPolyDataReader()
    reader3.SetFileName('test13.vtk')

    app = vtk.vtkAppendPolyData()

    app.AddInputConnection(reader.GetOutputPort())

    tr = vtk.vtkTransform()
    tr.Translate(-50.916666, -1.083333, 0)
    tr.RotateZ(90)

    tp = vtk.vtkTransformPolyDataFilter()
    tp.SetTransform(tr)
    tp.SetInputConnection(reader2.GetOutputPort())

    app.AddInputConnection(tp.GetOutputPort())

    tr2 = vtk.vtkTransform()
    tr2.Translate(-50.916666, -1.083333, 0)

    tp2 = vtk.vtkTransformPolyDataFilter()
    tp2.SetTransform(tr2)
    tp2.SetInputConnection(reader3.GetOutputPort())

    app.AddInputConnection(tp2.GetOutputPort())

    return app
示例#3
0
文件: brick.py 项目: zippy84/vtkbool
def add_stud(prev, x, y):
    cylA = create_cylinder(r=2.5, h=2.)

    trA = vtk.vtkTransform()
    trA.Translate(x, y, 10.6)
    trA.RotateX(90)

    tfA = vtk.vtkTransformPolyDataFilter()
    tfA.SetTransform(trA)
    tfA.SetInputConnection(cylA.GetOutputPort())

    bA = vtkboolPython.vtkPolyDataBooleanFilter()
    bA.SetInputConnection(prev.GetOutputPort())
    bA.SetInputConnection(1, tfA.GetOutputPort())
    bA.SetOperModeToUnion()
    bA.DecPolysOff()

    cylB = create_cylinder(r=1.5, h=1.)

    trB = vtk.vtkTransform()
    trB.Translate(x, y, 9.1)
    trB.RotateX(90)

    tfB = vtk.vtkTransformPolyDataFilter()
    tfB.SetTransform(trB)
    tfB.SetInputConnection(cylB.GetOutputPort())

    bB = vtkboolPython.vtkPolyDataBooleanFilter()
    bB.SetInputConnection(bA.GetOutputPort())
    bB.SetInputConnection(1, tfB.GetOutputPort())
    bB.SetOperModeToDifference()
    bB.DecPolysOff()

    return bB
def vtk_ellipsoid_topomesh(ellipsoid_radius=50.0, ellipsoid_scales=[1,1,1], ellipsoid_axes=np.diag(np.ones(3)), ellipsoid_center=np.zeros(3)):
    """
    """      
    import vtk
    from openalea.cellcomplex.property_topomesh.utils.image_tools import vtk_polydata_to_triangular_mesh

    ico = vtk.vtkPlatonicSolidSource()
    ico.SetSolidTypeToIcosahedron()
    ico.Update()

    subdivide = vtk.vtkLoopSubdivisionFilter()
    subdivide.SetNumberOfSubdivisions(3)
    subdivide.SetInputConnection(ico.GetOutputPort())
    subdivide.Update()

    scale_transform = vtk.vtkTransform()
    scale_factor = ellipsoid_radius/(np.sqrt(2)/2.)
    scale_transform.Scale(scale_factor,scale_factor,scale_factor)

    ellipsoid_sphere = vtk.vtkTransformPolyDataFilter()
    ellipsoid_sphere.SetInput(subdivide.GetOutput())
    ellipsoid_sphere.SetTransform(scale_transform)
    ellipsoid_sphere.Update()

    ellipsoid_transform = vtk.vtkTransform()
    axes_transform = vtk.vtkLandmarkTransform()
    source_points = vtk.vtkPoints()
    source_points.InsertNextPoint([1,0,0])
    source_points.InsertNextPoint([0,1,0])
    source_points.InsertNextPoint([0,0,1])
    target_points = vtk.vtkPoints()
    target_points.InsertNextPoint(ellipsoid_axes[0])
    target_points.InsertNextPoint(ellipsoid_axes[1])
    target_points.InsertNextPoint(ellipsoid_axes[2])
    axes_transform.SetSourceLandmarks(source_points)
    axes_transform.SetTargetLandmarks(target_points)
    axes_transform.SetModeToRigidBody()
    axes_transform.Update()
    ellipsoid_transform.SetMatrix(axes_transform.GetMatrix())
    ellipsoid_transform.Scale(ellipsoid_scales[0],ellipsoid_scales[1],ellipsoid_scales[2])
    center_transform = vtk.vtkTransform()
    center_transform.Translate(ellipsoid_center[0],ellipsoid_center[1],ellipsoid_center[2])
    center_transform.Concatenate(ellipsoid_transform)
    ellipsoid_ellipsoid = vtk.vtkTransformPolyDataFilter()
    ellipsoid_ellipsoid.SetInput(ellipsoid_sphere.GetOutput())
    ellipsoid_ellipsoid.SetTransform(center_transform)
    ellipsoid_ellipsoid.Update()

    ellipsoid_mesh = vtk_polydata_to_triangular_mesh(ellipsoid_ellipsoid.GetOutput())

    topomesh = triangle_topomesh(ellipsoid_mesh.triangles.values(),ellipsoid_mesh.points)

    return topomesh
示例#5
0
    def __init__(self, scale=0.01, **kwargs):
        kwargs["scale"] = scale

        self.poly_data = vtk.vtkPolyData()

        self.arrow_source = vtk.vtkArrowSource()

        self.transform = vtk.vtkTransform()
        
        self.transform_poly_data_filter = vtk.vtkTransformPolyDataFilter()
        self.transform_poly_data_filter.SetTransform(self.transform)
        self.transform_poly_data_filter.SetInputConnection(self.arrow_source.GetOutputPort())

        self.glyph = vtk.vtkGlyph3D()
        self.glyph.OrientOn()
        self.glyph.SetVectorModeToUseNormal()
        self.glyph.SetInput(self.poly_data)
        self.glyph.SetSourceConnection(self.transform_poly_data_filter.GetOutputPort())

        self.mapper = vtk.vtkPolyDataMapper()
        self.mapper.SetInputConnection(self.glyph.GetOutputPort())

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

        self._process_kwargs(**kwargs)
示例#6
0
def transformPolyData(polyData, transform):

    t = vtk.vtkTransformPolyDataFilter()
    t.SetTransform(transform)
    t.SetInput(shallowCopy(polyData))
    t.Update()
    return shallowCopy(t.GetOutput())
 def __init__(self, module_manager):
     SimpleVTKClassModuleBase.__init__(
         self, module_manager,
         vtk.vtkTransformPolyDataFilter(), 'Processing.',
         ('vtkPolyData',), ('vtkPolyData',),
         replaceDoc=True,
         inputFunctions=None, outputFunctions=None)
示例#8
0
 def save(self): # writer to new file
     logger.log('Exporting temp STL of model %s...' % self.name)
     # Extract transformations done to the actor
     matrix = vtk.vtkMatrix4x4() 
     self.getActor().GetMatrix(matrix)
     # Apply transformation
     transform = vtk.vtkTransform()
     transform.SetMatrix(matrix)
     # T
     t_filter = vtk.vtkTransformPolyDataFilter()
     t_filter.SetInput(self.getPolyData())
     t_filter.SetTransform(transform)
     # Triangle filter
     #vtkTriangleFilter
     # Clean Polydata
     #vtkcleanpolydata
     # Simplify the model
     #vtk.vtkDecimate
     # Save data to a STL file
     writer = vtk.vtkSTLWriter()
     writer.SetFileName('temp.stl')
     writer.SetInputConnection(t_filter.GetOutputPort())
     writer.SetFileTypeToBinary()
     writer.Write()
     logger.log('End exporting')
示例#9
0
def createCylinderActor(color=None,
                        radius=0.25,
                        height=0.3,
                        center=None,
                        ):
  cylinder = vtk.vtkCylinderSource()
  cylinder.SetResolution(128)
  cylinder.SetRadius(radius)
  cylinder.SetHeight(height)
  cylinderMapper = vtk.vtkPolyDataMapper()
  polyDataFilter = vtk.vtkTransformPolyDataFilter()
  polyDataFilter.SetInputConnection(cylinder.GetOutputPort())

  transform = vtk.vtkTransform()
  if center is not None:
    transform.Translate(*center)
  else:
    transform.Translate(0,0,height/2)
  transform.RotateWXYZ(90, 1,0,0)
  polyDataFilter.SetTransform(transform)

  cylinderMapper.SetInputConnection(polyDataFilter.GetOutputPort())
  cylinderActor = vtk.vtkActor()
  cylinderActor.SetMapper(cylinderMapper)
  if color is not None:
    cylinderActor.GetProperty().SetColor(color)
  return cylinderActor
示例#10
0
    def __init__(self, renderers, isRightHand):
        '''
        Initialize the user model.
        '''
        # Call the parent constructor
        super(Hand,self).__init__(renderers)
        
        filename = "../scene/media/rhand.stl"
         
        reader = vtk.vtkSTLReader()
        reader.SetFileName(filename)
        
        # Do the internal transforms to make it look along unit-z, do it with a quick transform
        trans = vtk.vtkTransform()
        trans.RotateZ(180)
        if isRightHand == False: #Flip with a horizontal flip using a -1 scale
            trans.Scale([-1, 1, 1])

        transF = vtk.vtkTransformPolyDataFilter()
        transF.SetInputConnection(reader.GetOutputPort())
        transF.SetTransform(trans)
         
        self.__mapper = vtk.vtkPolyDataMapper()
        #if vtk.VTK_MAJOR_VERSION <= 5:
        #    self.__mapper.SetInput(reader.GetOutput())
        #else:
        self.__mapper.SetInputConnection(transF.GetOutputPort())
         
        self.vtkActor.SetMapper(self.__mapper)
示例#11
0
def add_tube(prev, x, y):
    cylA = create_cylinder(r=3.155, h=8.6)

    cube = vtk.vtkCubeSource()
    cube.SetXLength(.75)
    cube.SetYLength(6.6)
    cube.SetZLength(13.6)
    cube.SetCenter(0, 1, 0)

    bA = vtkbool.vtkPolyDataBooleanFilter()
    bA.SetInputConnection(cylA.GetOutputPort())
    bA.SetInputConnection(1, cube.GetOutputPort())
    bA.SetOperModeToUnion()

    cylB = create_cylinder(r=2.405, h=8.6)

    bB = vtkbool.vtkPolyDataBooleanFilter()
    bB.SetInputConnection(bA.GetOutputPort())
    bB.SetInputConnection(1, cylB.GetOutputPort())
    bB.SetOperModeToDifference()

    tr = vtk.vtkTransform()
    tr.Translate(x, y, 4.3)
    tr.RotateX(90)

    tf = vtk.vtkTransformPolyDataFilter()
    tf.SetTransform(tr)
    tf.SetInputConnection(bB.GetOutputPort())

    bC = vtkbool.vtkPolyDataBooleanFilter()
    bC.SetInputConnection(prev.GetOutputPort())
    bC.SetInputConnection(1, tf.GetOutputPort())
    bC.SetOperModeToUnion()

    return bC
    def create_glyphs (self, poly):    
        if self.glyph_type == 'sphere':
            glyph = vtk.vtkSphereSource()
            glyph.SetRadius(1)
            glyph.SetPhiResolution(8)
            glyph.SetThetaResolution(8)
        elif self.glyph_type == 'cylinder':
            glyph = vtk.vtkCylinderSource()
            glyph.SetHeight(self.height)
            glyph.SetRadius(self.radius)
            glyph.SetCenter(0,0,0)
            glyph.SetResolution(10)
            glyph.CappingOn()

        tt = vtk.vtkTransform()
        tt.RotateZ(90)
        tf = vtk.vtkTransformPolyDataFilter()
        tf.SetInput(glyph.GetOutput())
        tf.SetTransform(tt)
        tf.Update()

        glypher = vtk.vtkGlyph3D()
        glypher.SetInput(poly)
        glypher.SetSource(tf.GetOutput())
        glypher.SetVectorModeToUseNormal()
        glypher.SetScaleModeToScaleByScalar()
        glypher.SetScaleFactor(self.glyph_scale_factor)
        glypher.Update()

        return glypher
示例#13
0
def makeCylinderPtsVTP(locXYZ,radius=50,height=50,res=10):
    # Load the file
    if type(locXYZ) == np.ndarray:
        loc = locXYZ
    elif type(locXYZ) == str:
        loc = np.genfromtxt(locXYZ)
    # Make append poly filter
    appPoly = vtk.vtkAppendPolyData()
    # Loop through all the locations
    for pt in loc[:,0:3]:
    	# Make the cylinters
        cyl = vtk.vtkCylinderSource()
        cyl.SetCenter(pt)
        cyl.SetRadius(radius)
        cyl.SetHeight(height)
        cyl.SetResolution(res)
        # Rotate to be vertical
        rot = vtk.vtkTransform()
        rot.Translate(-pt)
        rot.PostMultiply()
        rot.RotateX(90)
        rot.Translate(pt)
        tranFor = vtk.vtkTransformPolyDataFilter()
        tranFor.SetInputConnection(cyl.GetOutputPort())
        tranFor.SetTransform(rot)
        tranFor.Update()
        # Append
        appPoly.AddInputConnection(tranFor.GetOutputPort())
    # Update and return.
    appPoly.Update()
    return appPoly.GetOutput()
 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
示例#15
0
    def GetLineFromWidget(self, obj, event):

        if self.Type == "freehand":
            path = vtk.vtkPolyData()
            obj.GetPath(path)
        elif self.Type == "contour":
            path = self.ImageTracerWidget.GetRepresentation().GetContourRepresentationAsPolyData()

        spacing = self.Image.GetSpacing()

        translation = [0.0, 0.0, 0.0]
        translation[self.Axis] = self.SliceVOI[self.Axis * 2] * spacing[self.Axis]

        transform = vtk.vtkTransform()
        transform.Translate(translation)

        pathTransform = vtk.vtkTransformPolyDataFilter()
        pathTransform.SetInput(path)
        pathTransform.SetTransform(transform)
        pathTransform.Update()

        self.Line = pathTransform.GetOutput()

        if self.Line.GetSource():
            self.Line.GetSource().UnRegisterAllOutputs()
示例#16
0
    def GetPolyData(self):
        """Return a vtkPolyData that bounding the ROI."""

        trans = vtk.vtkTransformPolyDataFilter()
        trans.SetInput(self._cylinder.GetOutput())
        trans.SetTransform(self.GetTransform())
        return trans.GetOutput()
    def __init__(self):

        # Creates a cube image of height 0, thus creating a plane.
        cube = vtk.vtkCubeSource()
        cube.SetXLength(120)
        cube.SetYLength(120)
        cube.SetZLength(0)

        #cubeTransform = vtk.vtkTransform()
        #cubeTransform.Translate(0, 0, 0)
        
        cubeMapper = vtk.vtkPolyDataMapper()
        cubeMapper.SetInputConnection(cube.GetOutputPort())
        
        cubeTransformFilter = vtk.vtkTransformPolyDataFilter()
        cubeTransformFilter.SetInputConnection(cube.GetOutputPort())
        #cubeTransformFilter.SetTransform(cubeTransform)
        
        appendFilter = vtk.vtkAppendPolyData()
        #appendFilter.AddInputConnection(line.GetOutputPort())
        appendFilter.AddInputConnection(cubeTransformFilter.GetOutputPort())
       
        # gets the location of the tablet
        self.x = GlobalVariables.imageXDist/2.0 # @UndefinedVariable
        self.y = GlobalVariables.imageYDist/2.0 # @UndefinedVariable
        self.z = GlobalVariables.imageZDist/2.0 # @UndefinedVariable
        
        # moves the cube actor which is what moves the cursor
        self.cubeActor = vtk.vtkActor()
        self.cubeActor.SetMapper(cubeMapper)
        self.cubeActor.GetProperty().SetColor(0.2, 0.6, 0.8)
        self.cubeActor.SetPosition(self.x,self.y,self.z)#(self.sampleSpacing[0]/2,self.sampleSpacing[1]/2,self.sampleSpacing[2]/2)#(-30, -30, -150) #(70,90,50)
示例#18
0
    def __init__(self,center=(0,-2,0) , radius=0.5, height=2, color=(0,1,1),
                    rotXYZ=(0,0,0), resolution=50 ):
        """ cylinder """
        self.src = vtk.vtkCylinderSource()
        self.src.SetCenter(0,0,0)
        self.src.SetHeight(height)
        self.src.SetRadius(radius)
        self.src.SetResolution(resolution)
        # SetResolution
        # SetCapping(int)
        # CappingOn() CappingOff()
        
        # this transform rotates the cylinder so it is vertical
        # and then translates the lower tip to the center point
        transform = vtk.vtkTransform()
        transform.Translate(center[0], center[1], center[2]+height/2)
        transform.RotateX(rotXYZ[0])
        transformFilter=vtk.vtkTransformPolyDataFilter()
        transformFilter.SetTransform(transform)
        transformFilter.SetInputConnection(self.src.GetOutputPort())
        transformFilter.Update()

        
        self.mapper = vtk.vtkPolyDataMapper()
        #self.mapper.SetInput(self.src.GetOutput())
        self.mapper.SetInput( transformFilter.GetOutput() )
        self.SetMapper(self.mapper)
        self.SetColor(color)
示例#19
0
 def __init__(self,  center=(-2,0,0), radius = 1, angle=45, height=0.4, color=(1,1,0) , resolution=60):
     """ cone"""
     self.src = vtk.vtkConeSource()
     self.src.SetResolution(resolution)
     self.src.SetRadius( radius ) 
     #self.src.SetAngle( angle )
     self.src.SetHeight( height )
     #self.src.SetCenter(center)
     
     transform = vtk.vtkTransform()
     transform.Translate(center[0], center[1], center[2] - self.src.GetHeight()/2)
     #transform.RotateX(rotXYZ[0])
     transform.RotateY( -90 )
     #transform.RotateZ(rotXYZ[2])
     transformFilter=vtk.vtkTransformPolyDataFilter()
     transformFilter.SetTransform(transform)
     transformFilter.SetInputConnection(self.src.GetOutputPort())
     transformFilter.Update()
     
     self.mapper = vtk.vtkPolyDataMapper()
     self.mapper.SetInput(transformFilter.GetOutput())
     
     
     #self.mapper = vtk.vtkPolyDataMapper()
     #self.mapper.SetInput(self.src.GetOutput())
     self.SetMapper(self.mapper)
     self.SetColor(color)
示例#20
0
 def TransformPolyDataFilter(self, currentElement):
     transFilter = vtk.vtkTransformPolyDataFilter()
     # 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('  .. <TransformPolyDataFilter> failed to SetInputConnection')
     else:
         self.logger.error('  .. <TransformPolyDataFilter> needs an Algorithm-type childElement')
     if TransformElement != '':
         transform = self.namesToFunctions[TransformElement.tag](TransformElement)
         try:
             transFilter.SetTransform(transform)
         except:
             self.logger.error('  .. <TransformPolyDataFilter> failed to SetTransform')
     else:
         self.logger.error('<TransformPolyDataFilter> needs an Transform-type childElement')
     return transFilter
示例#21
0
def rotateMesh(mesh, axis=1, angle=0):
    try:
        print("Rotating surface: axis=", axis, "angle=", angle)
        matrix = vtk.vtkTransform()
        if axis == 0:
            matrix.RotateX(angle)
        if axis == 1:
            matrix.RotateY(angle)
        if axis == 2:
            matrix.RotateZ(angle)
        tfilter = vtk.vtkTransformPolyDataFilter()
        tfilter.SetTransform(matrix)
        if vtk.vtkVersion.GetVTKMajorVersion() >= 6:
            tfilter.SetInputData(mesh)
        else:
            tfilter.SetInput(mesh)
        tfilter.Update()
        mesh2 = tfilter.GetOutput()
        return mesh2
    except:
        print("Surface rotating failed")
        exc_type, exc_value, exc_traceback = sys.exc_info()
        traceback.print_exception(
            exc_type, exc_value, exc_traceback, limit=2, file=sys.stdout)
    return None
示例#22
0
 def __init__(self, renderers, name):
     '''
     Initialize the bot model.
     '''
     # Call the parent constructor
     super(RoverBot,self).__init__(renderers)
     
     filename = "../scene/media/rover.stl"
     
     self.__name = name
      
     reader = vtk.vtkSTLReader()
     reader.SetFileName(filename)
     
     # Do the internal transforms to make it look along unit-z, do it with a quick transform
     trans = vtk.vtkTransform()
     trans.Scale(0.05, 0.05, 0.05)
     trans.RotateX(-90)
     transF = vtk.vtkTransformPolyDataFilter()
     transF.SetInputConnection(reader.GetOutputPort())
     transF.SetTransform(trans)
      
     self.__mapper = vtk.vtkPolyDataMapper()
     #if vtk.VTK_MAJOR_VERSION <= 5:
     #    self.__mapper.SetInput(reader.GetOutput())
     #else:
     self.__mapper.SetInputConnection(transF.GetOutputPort())
      
     self.vtkActor.SetMapper(self.__mapper)
     
     # Set up all the children for this model
     self.__setupChildren(renderers)
     # Set it to [0,0,0] so that it updates all the children
     self.SetSceneObjectPosition([0, 0, 0])
示例#23
0
文件: world.py 项目: cjauvin/pypetree
 def select_point_cloud(self):
     if not self.scene.get_active_point_cloud(): return
     self.unselect_point_cloud()
     transform = vtk.vtkTransform()
     transform.SetMatrix(self.actor.GetMatrix())
     transform_filter = vtk.vtkTransformPolyDataFilter()
     transform_filter.SetInputConnection(self.src.GetOutputPort())
     transform_filter.SetTransform(transform)
     enclosed_pts = vtk.vtkSelectEnclosedPoints()
     if USING_VTK6:
         enclosed_pts.SetInputData(self.scene.get_active_point_cloud().polydata)
         enclosed_pts.SetSurfaceConnection(transform_filter.GetOutputPort())
     else:
         enclosed_pts.SetInput(self.scene.get_active_point_cloud().polydata)
         enclosed_pts.SetSurface(transform_filter.GetOutput())
     enclosed_pts.Update()
     inside_arr = enclosed_pts.GetOutput().GetPointData().\
       GetArray('SelectedPoints')
     self.selected_pts = []
     for i in range(inside_arr.GetNumberOfTuples()):
         if inside_arr.GetComponent(i, 0):
             self.scene.get_active_point_cloud().colors.\
               SetTuple3(i, *name_to_rgb('blue'))
             self.selected_pts.append(i)
             self.scene.get_active_point_cloud().selected_pts[i] += 1
     self.scene.get_active_point_cloud().colors.Modified()
     self.frame.ren_win.Render()
示例#24
0
    def Execute(self):

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

        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.vtkTransformPolyDataFilter()
        transformFilter.SetInput(self.Surface)
        transformFilter.SetTransform(transform)
        transformFilter.Update()

        self.Surface = transformFilter.GetOutput()

        if self.Surface.GetSource():
            self.Surface.GetSource().UnRegisterAllOutputs()
示例#25
0
    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)
示例#26
0
	def transform_back(self,pt,pd):
		#The reconstructed surface is transformed back to where the
		#original points are. (Hopefully) it is only a similarity
		#transformation.

		#1. Get bounding box of pt, get its minimum corner (left, bottom, least-z), at c0, pt_bounds

		#2. Get bounding box of surface pd, get its minimum corner (left, bottom, least-z), at c1, pd_bounds

		#3. compute scale as: 
		#      scale = (pt_bounds[1] - pt_bounds[0])/(pd_bounds[1] - pd_bounds[0]);

		#4. transform the surface by T := T(pt_bounds[0], [2], [4]).S(scale).T(-pd_bounds[0], -[2], -[4])

		pt_bounds=pt.GetBounds()

		pd_bounds=pd.GetBounds()

		scale = (pt_bounds[1] - pt_bounds[0])/(pd_bounds[1] - pd_bounds[0]);

		transp = vtk.vtkTransform()
		transp.Translate(pt_bounds[0], pt_bounds[2], pt_bounds[4]);
		transp.Scale(scale, scale, scale);
		transp.Translate(- pd_bounds[0], - pd_bounds[2], - pd_bounds[4]);

		tpd = vtk.vtkTransformPolyDataFilter();
		tpd.SetInput(pd);
		tpd.SetTransform(transp);
		tpd.Update();


		return tpd.GetOutput();
示例#27
0
def transform_polydata_from_disk_using_transform_object(in_filename, transform, out_filename):
    # Read it in.
    print "<io.py> Transforming ", in_filename, "->", out_filename, "..."
    start_time = time.time()
    pd = read_polydata(in_filename)
    elapsed_time = time.time() - start_time
    print "READ:", elapsed_time
    # Transform it.
    start_time = time.time()
    transformer = vtk.vtkTransformPolyDataFilter()
    if (vtk.vtkVersion().GetVTKMajorVersion() >= 6.0):
        transformer.SetInputData(pd)
    else:
        transformer.SetInput(pd)
    transformer.SetTransform(transform)
    transformer.Update()
    elapsed_time = time.time() - start_time
    print "TXFORM:", elapsed_time

    # Write it out.
    start_time = time.time()
    pd2 = transformer.GetOutput()
    write_polydata(pd2, out_filename)
    elapsed_time = time.time() - start_time
    print "WRITE:", elapsed_time

    # Clean up.
    del transformer
    del pd2
    del pd
示例#28
0
def transform_polydata_from_disk(in_filename, transform_filename, out_filename):
    # Read it in.
    print "<io.py> Transforming ", in_filename, "->", out_filename, "..."

    # Read the transform from disk because we cannot pickle it
    (root, ext) = os.path.splitext(transform_filename)
    print root, ext
    if ext == '.xfm':
        reader = vtk.vtkMNITransformReader()
        reader.SetFileName(transform_filename)
        reader.Update()
        transform = reader.GetTransform()
    elif ext == '.img':
        reader = vtk.vtkImageReader()
        reader.SetFileName(transform_filename)
        reader.Update()
        coeffs = reader.GetOutput()
        transform = vtk.vtkBSplineTransform()
        transform.SetCoefficients(coeffs)
        print coeffs
        print transform
    else:
        f = open(transform_filename, 'r')
        transform = vtk.vtkTransform()
        matrix = vtk.vtkMatrix4x4()
        for i in range(0,4):
            for j in range(0,4):
                matrix_val = float(f.readline())
                matrix.SetElement(i,j, matrix_val)
        transform.SetMatrix(matrix)
        del matrix

    start_time = time.time()
    pd = read_polydata(in_filename)
    elapsed_time = time.time() - start_time
    print "READ:", elapsed_time
    # Transform it.
    start_time = time.time()
    transformer = vtk.vtkTransformPolyDataFilter()
    if (vtk.vtkVersion().GetVTKMajorVersion() >= 6.0):
        transformer.SetInputData(pd)
    else:
        transformer.SetInput(pd)
    transformer.SetTransform(transform)
    transformer.Update()
    elapsed_time = time.time() - start_time
    print "TXFORM:", elapsed_time

    # Write it out.
    start_time = time.time()
    pd2 = transformer.GetOutput()
    write_polydata(pd2, out_filename)
    elapsed_time = time.time() - start_time
    print "WRITE:", elapsed_time

    # Clean up.
    del transformer
    del pd2
    del pd
    del transform
示例#29
0
    def __init__(self, renderers, radius = 2.0, height = 8.0, rotationXYZ = [0, 0, 0], offsetXYZ = [0, 0, 0]):
        '''
        Initialize the cylinder.
        '''
        # Call the parent constructor
        super(Cylinder,self).__init__(renderers)
        
        cylinderSource = vtk.vtkCylinderSource()
        cylinderSource.SetCenter(0.0, 0.0, 0.0)
        cylinderSource.SetRadius(radius)
        cylinderSource.SetHeight(height)
        # Make it a little more defined
        cylinderSource.SetResolution(24)
        
        # Transform scale it to the right size
        trans = vtk.vtkTransform()
        trans.Scale(1, 1, 1)
        trans.Translate(offsetXYZ[0], offsetXYZ[1], offsetXYZ[2])
        trans.RotateZ(rotationXYZ[2])  
        trans.RotateX(rotationXYZ[0])
        trans.RotateY(rotationXYZ[1])
        transF = vtk.vtkTransformPolyDataFilter()
        transF.SetInputConnection(cylinderSource.GetOutputPort())
        transF.SetTransform(trans)

         
        cylinderMapper = vtk.vtkPolyDataMapper()
        cylinderMapper.SetInputConnection(transF.GetOutputPort())
         
        self.vtkActor.SetMapper(cylinderMapper)
        # Change it to a red sphere
        self.vtkActor.GetProperty().SetColor(0.8, 0.8, 0.3)
            
    def Execute(self):

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

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

        referenceSystemsNormal1Array = self.ReferenceSystems.GetPointData().GetArray(self.ReferenceSystemsNormal1ArrayName)
        referenceSystemsNormal2Array = self.ReferenceSystems.GetPointData().GetArray(self.ReferenceSystemsNormal2ArrayName)

        referenceSystemPointId = 0
        
        if self.ReferenceSystemId != -1:
            referenceSystemsIdArray = self.ReferenceSystems.GetPointData().GetArray(self.ReferenceSystemsIdArrayName)
            for i in range(self.ReferenceSystems.GetNumberOfPoints()):
                referenceSystemId = int(referenceSystemsIdArray.GetTuple1(i))
                if referenceSystemId == self.ReferenceSystemId:
                    referenceSystemPointId = i
                    break

        currentOrigin = self.ReferenceSystems.GetPoint(referenceSystemPointId)
        currentNormal1 = referenceSystemsNormal1Array.GetTuple3(referenceSystemPointId)
        currentNormal2 = referenceSystemsNormal2Array.GetTuple3(referenceSystemPointId)

        transform = vtk.vtkTransform()
        transform.PostMultiply()
    
        translation = [0.0, 0.0, 0.0]
        translation[0] = self.ReferenceOrigin[0] - currentOrigin[0] 
        translation[1] = self.ReferenceOrigin[1] - currentOrigin[1]
        translation[2] = self.ReferenceOrigin[2] - currentOrigin[2]

        transform.Translate(translation)

        cross = [0.0,0.0,0.0]

        vtk.vtkMath.Cross(currentNormal1,self.ReferenceNormal1,cross)
        vtk.vtkMath.Normalize(cross)
        angle = self.ComputeAngle(currentNormal1,self.ReferenceNormal1)
        angle = angle / (2.0*vtk.vtkMath.Pi()) * 360.0;
        transform.RotateWXYZ(angle,cross)

        transformedNormal2 = transform.TransformNormal(currentNormal2)
        vtk.vtkMath.Cross(transformedNormal2,self.ReferenceNormal2,cross)
        vtk.vtkMath.Normalize(cross)
        angle = self.ComputeAngle(transformedNormal2,self.ReferenceNormal2)
        angle = angle / (2.0*vtk.vtkMath.Pi()) * 360.0;
        transform.RotateWXYZ(angle,cross)

        transformFilter = vtk.vtkTransformPolyDataFilter()
        transformFilter.SetInput(self.Surface)
        transformFilter.SetTransform(transform)
        transformFilter.Update()

        self.Surface = transformFilter.GetOutput()

        if self.Surface.GetSource():
            self.Surface.GetSource().UnRegisterAllOutputs()
示例#31
0
        def makeHandle():
            fn = vtk.vtkParametricTorus()
            fn.SetRingRadius(20)
            fn.SetCrossSectionRadius(7)

            source = vtk.vtkParametricFunctionSource()
            source.SetParametricFunction(fn)
            source.Update()

            trans = vtk.vtkTransform()
            trans.RotateX(90)
            trans.Translate(-8, 52, 25)
            rotate = vtk.vtkTransformPolyDataFilter()
            rotate.SetTransform(trans)
            rotate.SetInputConnection(source.GetOutputPort())
            rotate.Update()

            return rotate.GetOutput()
示例#32
0
    def Update_Scale(self, scale):
        modelObject = self.modelList[self.ui.modelList.currentRow()]
        transform = modelObject.transform

        self.reader = vtk.vtkSTLReader()
        self.reader.SetFileName(str(self.filename))

        self.mapper = vtk.vtkPolyDataMapper()
        self.mapper.SetInputConnection(self.reader.GetOutputPort())

        #create model actor
        self.actor = vtk.vtkActor()
        self.actor.GetProperty().SetColor(1, 1, 1)
        self.actor.GetProperty().SetOpacity(1)
        self.actor.SetMapper(self.mapper)

        #create outline mapper
        self.outline = vtk.vtkOutlineFilter()
        self.outline.SetInputConnection(self.reader.GetOutputPort())
        self.outlineMapper = vtk.vtkPolyDataMapper()
        self.outlineMapper.SetInputConnection(self.outline.GetOutputPort())

        #create outline actor
        self.outlineActor = vtk.vtkActor()
        self.outlineActor.SetMapper(self.outlineMapper)

        #add actors to parent render window
        self.parent.ren.AddActor(self.actor)
        self.parent.ren.AddActor(self.outlineActor)

        delta = modelObject.PreviousScale - modelObject.CurrentScale
        modelObject.transform
        #transform.Scale((float(scale)-modelObject.CurrentScale)/100.0, (float(scale)-modelObject.CurrentScale)/100.0, (float(scale)-modelObject.CurrentScale)/100.0)
        transform.Scale
        modelObject.CurrentScale = modelObject.CurrentScale + (
            float(scale) - modelObject.CurrentScale)
        transformFilter = vtk.vtkTransformPolyDataFilter()
        transformFilter.SetTransform(modelObject.transform)
        transformFilter.SetInputConnection(modelObject.reader.GetOutputPort())
        transformFilter.Update()
        modelObject.mapper.SetInputConnection(transformFilter.GetOutputPort())
        modelObject.mapper.Update()
        self.ren.Render()
        self.ModelView.Render()
示例#33
0
  def __init__(self, parent=None):
    
    # Defaults
    self.filename = ""
    self.gaussStandardDeviation = 1.2
    self.gaussRadius = 2
    self.magnification = 1
    self.isosurface = 1
    self.actorColor = [1.000, 0.000, 0.000]
    self.actorOpacity = 1.0
    self.actorVisibility = 1
    self.actorPickable = 1
    
    self.pipelineType = "MarchingCubes" # In the future we could define other types of pipelines
    self.pipelineDataType = None
    self.actorAdded = False
    
    self.processing_log = None
    self.image_info = None
    
    # Elements of the VTK pipeline
    self.reader = None
    self.gauss = vtk.vtkImageGaussianSmooth()
    self.pad = vtk.vtkImageConstantPad()
    self.resampler = vtk.vtkImageResize()
    self.marchingCubes = vtk.vtkImageMarchingCubes()
    self.mapper = vtk.vtkPolyDataMapper()
    self.mapperDS = vtk.vtkDataSetMapper()
    self.actor = vtk.vtkActor()
    self.transformPolyData = vtk.vtkTransformPolyDataFilter()
    
    # The vtkTransform is part of the pipeline. The matrix defines the vtkTransform, but we
    # store a copy in self.matrix for retrieval later.
    self.rigidBodyTransform = vtk.vtkTransform()
    self.rigidBodyTransform.Identity()
    self.rigidBodyTransform.PostMultiply() # Important so that transform concatenations is correct!

    self.matrix = vtk.vtkMatrix4x4()
    self.dim = [1,1,1]
    self.pos = [0,0,0]
    self.el_size_mm = [0.082,0.082,0.082]
    self.extent = [0,1,0,1,0,1]
    self.origin = [0,0,0]
    self.validForExtrusion = False
示例#34
0
def Hyperboloid(pos=(0, 0, 0), a2=1, value=0.5, height=1, axis=(0, 0, 1),
                c="magenta", alpha=1, res=100):
    """
    Build a hyperboloid of specified aperture `a2` and `height`, centered at `pos`.

    Full volumetric expression is:
        :math:`F(x,y,z)=a_0x^2+a_1y^2+a_2z^2+a_3xy+a_4yz+a_5xz+ a_6x+a_7y+a_8z+a_9`

    .. hint:: |mesh_bands| |mesh_bands.py|_
    """
    q = vtk.vtkQuadric()
    q.SetCoefficients(2, 2, -1 / a2, 0, 0, 0, 0, 0, 0, 0)
    # F(x,y,z) = a0*x^2 + a1*y^2 + a2*z^2
    #         + a3*x*y + a4*y*z + a5*x*z
    #         + a6*x   + a7*y   + a8*z  +a9
    sample = vtk.vtkSampleFunction()
    sample.SetSampleDimensions(res, res, res)
    sample.SetImplicitFunction(q)

    contours = vtk.vtkContourFilter()
    contours.SetInputConnection(sample.GetOutputPort())
    contours.GenerateValues(1, value, value)
    contours.Update()

    axis = np.array(axis) / np.linalg.norm(axis)
    theta = np.arccos(axis[2])
    phi = np.arctan2(axis[1], axis[0])
    t = vtk.vtkTransform()
    t.PostMultiply()
    t.RotateY(np.rad2deg(theta))
    t.RotateZ(np.rad2deg(phi))
    t.Scale(1, 1, height)
    tf = vtk.vtkTransformPolyDataFilter()
    tf.SetInputData(contours.GetOutput())
    tf.SetTransform(t)
    tf.Update()
    pd = tf.GetOutput()

    actor = Actor(pd, c, alpha).flipNormals()
    actor.GetProperty().SetInterpolationToPhong()
    actor.mapper.ScalarVisibilityOff()
    actor.SetPosition(pos)
    settings.collectable_actors.append(actor)
    return actor
示例#35
0
def Paraboloid(pos=(0, 0, 0), r=1, height=1, axis=(0, 0, 1), c="cyan", alpha=1, res=50):
    """
    Build a paraboloid of specified height and radius `r`, centered at `pos`.

    .. note::
        Full volumetric expression is:
            :math:`F(x,y,z)=a_0x^2+a_1y^2+a_2z^2+a_3xy+a_4yz+a_5xz+ a_6x+a_7y+a_8z+a_9`

            |paraboloid|
    """
    quadric = vtk.vtkQuadric()
    quadric.SetCoefficients(1, 1, 0, 0, 0, 0, 0, 0, height / 4, 0)
    # F(x,y,z) = a0*x^2 + a1*y^2 + a2*z^2
    #         + a3*x*y + a4*y*z + a5*x*z
    #         + a6*x   + a7*y   + a8*z  +a9
    sample = vtk.vtkSampleFunction()
    sample.SetSampleDimensions(res, res, res)
    sample.SetImplicitFunction(quadric)

    contours = vtk.vtkContourFilter()
    contours.SetInputConnection(sample.GetOutputPort())
    contours.GenerateValues(1, 0.01, 0.01)
    contours.Update()

    axis = np.array(axis) / np.linalg.norm(axis)
    theta = np.arccos(axis[2])
    phi = np.arctan2(axis[1], axis[0])
    t = vtk.vtkTransform()
    t.PostMultiply()
    t.RotateY(np.rad2deg(theta))
    t.RotateZ(np.rad2deg(phi))
    t.Scale(r, r, r)
    tf = vtk.vtkTransformPolyDataFilter()
    tf.SetInputData(contours.GetOutput())
    tf.SetTransform(t)
    tf.Update()
    pd = tf.GetOutput()

    actor = Actor(pd, c, alpha).flipNormals()
    actor.GetProperty().SetInterpolationToPhong()
    actor.mapper.ScalarVisibilityOff()
    actor.SetPosition(pos)
    settings.collectable_actors.append(actor)
    return actor
def ellipsoid(pos=[0, 0, 0],
              axis1=[1, 0, 0],
              axis2=[0, 2, 0],
              axis3=[0, 0, 3],
              c='c',
              alpha=1,
              legend=None,
              texture=None,
              res=24):
    """
    Build a 3D ellipsoid centered at position pos.
    Axis1 and axis2 are only used to define sizes and one azimuth angle
    """
    elliSource = vtk.vtkSphereSource()
    elliSource.SetThetaResolution(res)
    elliSource.SetPhiResolution(res)
    elliSource.Update()
    l1 = np.linalg.norm(axis1)
    l2 = np.linalg.norm(axis2)
    l3 = np.linalg.norm(axis3)
    axis1 = np.array(axis1) / l1
    axis2 = np.array(axis2) / l2
    axis3 = np.array(axis3) / l3
    angle = np.arcsin(np.dot(axis1, axis2))
    theta = np.arccos(axis3[2])
    phi = np.arctan2(axis3[1], axis3[0])

    t = vtk.vtkTransform()
    t.PostMultiply()
    t.Scale(l1, l2, l3)
    t.RotateX(angle * 57.3)
    t.RotateY(theta * 57.3)
    t.RotateZ(phi * 57.3)
    tf = vtk.vtkTransformPolyDataFilter()
    vu.setInput(tf, elliSource.GetOutput())
    tf.SetTransform(t)
    tf.Update()
    pd = tf.GetOutput()

    actor = vu.makeActor(pd, c=c, alpha=alpha, legend=legend, texture=texture)
    actor.GetProperty().BackfaceCullingOn()
    actor.GetProperty().SetInterpolationToPhong()
    actor.SetPosition(pos)
    return actor
def LabelToSurface(label_path, surface_path, lcc=False):
    print("Converting segmentation label to surface file:", label_path)

    # binary path
    bin_path = "D:/Dr_Simon_Yu/CFD_intracranial/code/cxx/label_to_mesh/build/Release/LabelToMesh.exe"

    # convert to binary file
    command = bin_path + " " + label_path + " " + surface_path + " 1 1"
    # print(command)
    os.system(command)

    reader = vtk.vtkGenericDataObjectReader()
    reader.SetFileName(surface_path)
    reader.Update()
    surface = reader.GetOutput()

    transform = vtk.vtkTransform()
    transform.Scale(-1, -1, 1)

    transformFilter = vtk.vtkTransformPolyDataFilter()
    transformFilter.SetInputData(surface)
    transformFilter.SetTransform(transform)
    transformFilter.Update()
    surface = transformFilter.GetOutput()

    smoothFilter = vtk.vtkSmoothPolyDataFilter()
    smoothFilter.SetInputData(surface)
    smoothFilter.SetNumberOfIterations(15)
    smoothFilter.SetRelaxationFactor(0.1)
    smoothFilter.FeatureEdgeSmoothingOff()
    smoothFilter.BoundarySmoothingOn()
    smoothFilter.Update()
    surface = smoothFilter.GetOutput()

    if lcc:
        connectedFilter = vtk.vtkConnectivityFilter()
        connectedFilter.SetInputData(surface)
        connectedFilter.Update()
        surface = connectedFilter.GetOutput()

    writer = vtk.vtkGenericDataObjectWriter()
    writer.SetFileName(surface_path)
    writer.SetInputData(surface)
    writer.Update()
示例#38
0
def main():
    colors = vtk.vtkNamedColors()

    # Create the polydata geometry
    sphereSource = vtk.vtkSphereSource()
    sphereSource.Update()

    # Set up the actor to display the untransformed polydata
    originalMapper = vtk.vtkPolyDataMapper()
    originalMapper.SetInputConnection(sphereSource.GetOutputPort())

    originalActor = vtk.vtkActor()
    originalActor.SetMapper(originalMapper)
    originalActor.GetProperty().SetColor(colors.GetColor3d("blue"))

    # Set up the transform filter
    translation = vtk.vtkTransform()
    translation.Translate(1.0, 2.0, 3.0)

    transformFilter = vtk.vtkTransformPolyDataFilter()
    transformFilter.SetInputConnection(sphereSource.GetOutputPort())
    transformFilter.SetTransform(translation)
    transformFilter.Update()

    # Set up the actor to display the transformed polydata
    transformedMapper = vtk.vtkPolyDataMapper()
    transformedMapper.SetInputConnection(transformFilter.GetOutputPort())

    transformedActor = vtk.vtkActor()
    transformedActor.SetMapper(transformedMapper)
    transformedActor.GetProperty().SetColor(colors.GetColor3d("red"))

    # Set up the rest of the visualization pipeline
    renderer = vtk.vtkRenderer()
    renderer.AddActor(originalActor)
    renderer.AddActor(transformedActor)
    renderer.SetBackground(
        colors.GetColor3d("green"))  # Set renderer's background color to green

    renderWindow = vtk.vtkRenderWindow()
    renderWindow.AddRenderer(renderer)
    renderWindowInteractor = vtk.vtkRenderWindowInteractor()
    renderWindowInteractor.SetRenderWindow(renderWindow)
    renderWindowInteractor.Start()
示例#39
0
def drawArrow(start_point, end_point):
    math = vtk.vtkMath()
    # X-Axis is a vector from start to end
    normX = np.subtract(start_point, end_point)
    length = np.linalg.norm(normX)
    normX = np.divide(normX, length)

    # Z axis is an arbitrary vector cross X
    arbitrary = [0.0, 0.0, 1.0]
    normZ = np.cross(normX, arbitrary)

    # Y-Axis is Z cross X
    normY = np.cross(normZ, normX)

    tVec_at_b0_mat = vtk.vtkMatrix4x4()
    tVec_at_b0_mat.Identity()

    for i in range(3):
        tVec_at_b0_mat.SetElement(i, 0, normX[i])
        tVec_at_b0_mat.SetElement(i, 1, normY[i])
        tVec_at_b0_mat.SetElement(i, 2, normZ[i])

    arrowBase = vtk.vtkArrowSource()
    arrowBase.Update()

    print(arrowBase.GetTipLength())
    print(arrowBase.GetTipRadius())
    print(arrowBase.GetTipResolution())

    print(arrowBase.GetShaftRadius())
    print(arrowBase.GetShaftResolution())

    arrow_transform = vtk.vtkTransform()
    arrow_transform.Translate(start_point)
    arrow_transform.Concatenate(tVec_at_b0_mat)
    arrow_transform.Scale(length, length, length)
    arrow_transform.Update()

    transformPD = vtk.vtkTransformPolyDataFilter()
    transformPD.SetInputData(arrowBase.GetOutput())
    transformPD.SetTransform(arrow_transform)
    transformPD.Update()

    return transformPD.GetOutput()
示例#40
0
 def updateSkeletonModel(self):
     appender = vtk.vtkAppendPolyData()
     vesselToWorld = self.vesselModelToVessel.GetTransformToParent()
     for name, visiblilityFlag in self.visiblePolydata.iteritems():
         if visiblilityFlag:
             poly = self.modelPolydata[name]
             transformFilter = vtk.vtkTransformPolyDataFilter()
             transformFilter.SetTransform(vesselToWorld)
             transformFilter.SetInputData(poly)
             transformFilter.Update()
             transformedPoly = transformFilter.GetOutput()
             appender.AddInputData(transformedPoly)
             self.modelPolydata[name] = transformedPoly
     appender.Update()
     modelNode = slicer.util.getFirstNodeByName(self.SKELETON_MODEL_NAME)
     if modelNode is None:
         logging.error("Model node not found: {0}".format(
             self.SKELETON_MODEL_NAME))
     modelNode.SetAndObservePolyData(appender.GetOutput())
示例#41
0
 def write_isosurface_from_labelmap(label_name, surface_name):
     if not os.path.exists(os.path.split(surface_name)[0]):
         print("Creating: ", os.path.split(surface_name)[0])
         os.mkdir(os.path.split(surface_name)[0])
     
     reader = vtk.vtkNIFTIImageReader()
     reader.SetFileName(label_name)
     reader.Update()
     
     annotation = reader.GetOutput()
         
     ## Marching cubes. 
     mc = vtk.vtkMarchingCubes()
     mc.SetInputData(annotation)
     mc.SetValue(0,0.5)
     mc.Update()
     surf = mc.GetOutput()
     
     ## Choose only largest component
     connectivity_filter = vtk.vtkPolyDataConnectivityFilter()
     connectivity_filter.SetInputData(surf)
     connectivity_filter.SetExtractionModeToLargestRegion()
     connectivity_filter.Update()
         
     ## Transform surface to fit in coordinate system
     transform = vtk.vtkTransform()
     transform.SetMatrix(reader.GetQFormMatrix())
     tfilter = vtk.vtkTransformPolyDataFilter()
     tfilter.SetTransform(transform)
     tfilter.SetInputData(connectivity_filter.GetOutput())
     tfilter.Update()
         
     # Save as vtk: 
     norms = vtk.vtkPolyDataNormals()
     norms.SetInputConnection(tfilter.GetOutputPort())
     norms.SetFlipNormals(True)
     norms.SetSplitting(False)
 
     writer = vtk.vtkPolyDataWriter()
     writer.SetInputConnection(norms.GetOutputPort())
     writer.SetFileTypeToBinary()
     writer.SetFileName(surface_name)
     writer.Write()
示例#42
0
def mesh_transform(polydata, rotate_axis, angle=180):

    transform = vtk.vtkTransform()
    if rotate_axis == 'X':
        transform.RotateX(angle)
    elif rotate_axis == 'Y':
        transform.RotateY(angle)
    elif rotate_axis == 'Z':
        transform.RotateZ(angle)
    else:
        print("you have to choose X or Y or Z")

    transformFilter = vtk.vtkTransformPolyDataFilter()
    transformFilter.SetInputData(polydata)
    transformFilter.SetTransform(transform)
    transformFilter.Update()
    polydata = transformFilter.GetOutput()

    return polydata
示例#43
0
def Ellipsoid(pos=(0, 0, 0), axis1=(1, 0, 0), axis2=(0, 2, 0), axis3=(0, 0, 3),
              c="c", alpha=1, res=24):
    """
    Build a 3D ellipsoid centered at position `pos`.

    .. note:: `axis1` and `axis2` are only used to define sizes and one azimuth angle.

    |projectsphere|
    """
    elliSource = vtk.vtkSphereSource()
    elliSource.SetThetaResolution(res)
    elliSource.SetPhiResolution(res)
    elliSource.Update()
    l1 = np.linalg.norm(axis1)
    l2 = np.linalg.norm(axis2)
    l3 = np.linalg.norm(axis3)
    axis1 = np.array(axis1) / l1
    axis2 = np.array(axis2) / l2
    axis3 = np.array(axis3) / l3
    angle = np.arcsin(np.dot(axis1, axis2))
    theta = np.arccos(axis3[2])
    phi = np.arctan2(axis3[1], axis3[0])

    t = vtk.vtkTransform()
    t.PostMultiply()
    t.Scale(l1, l2, l3)
    t.RotateX(np.rad2deg(angle))
    t.RotateY(np.rad2deg(theta))
    t.RotateZ(np.rad2deg(phi))
    tf = vtk.vtkTransformPolyDataFilter()
    tf.SetInputData(elliSource.GetOutput())
    tf.SetTransform(t)
    tf.Update()
    pd = tf.GetOutput()

    actor = Actor(pd, c=c, alpha=alpha)
    actor.GetProperty().BackfaceCullingOn()
    actor.GetProperty().SetInterpolationToPhong()
    actor.SetPosition(pos)
    actor.base = -np.array(axis1) / 2 + pos
    actor.top = np.array(axis1) / 2 + pos
    settings.collectable_actors.append(actor)
    return actor
    def execute(self):
        for kk,file_name in enumerate(self.file_list):
            reader=vtk.vtkPolyDataReader()
            reader.SetFileName(file_name)
            reader.Update()
            
            poly = self.compute_radius(reader.GetOutput(),spacing_list[kk])
            if self.use_field_data == False:
                poly.GetPointData().\
                    SetNormals(poly.GetPointData().\
                               GetArray(self.normal_map[self.feature_type]))
            else:
                poly.GetPointData().\
                    SetNormals(poly.GetFieldData().\
                               GetArray(self.normal_map[self.feature_type]))
        
            glypher=self.create_glyphs(poly)
            if len(self.color_list) <= kk:
                color=[]
            else:
                color=self.color_list[kk]
            if len(self.opacity_list) <= kk:
                opacity=1
            else:
                opacity=self.opacity_list[kk]
            self.create_actor(glypher,color=color,opacity=opacity)
        
        if len(self.lung)>0:
            reader=vtk.vtkPolyDataReader()
            reader.SetFileName(self.lung)
            reader.Update()
            tt=vtk.vtkTransform()
            tt.Identity()
            tt.GetMatrix().SetElement(0,0,-1)
            tt.GetMatrix().SetElement(1,1,-1)
            tf=vtk.vtkTransformPolyDataFilter()
            tf.SetTransform(tt)
            tf.SetInput(reader.GetOutput())
            tf.SetTransform(tt)
            self.create_actor(tf,0.1,color=[0.8,0.4,0.01])

        self.add_color_bar()
        self.render()
    def create_atoms2(self, system):
        atoms = system.all_sites()
        lattice = system.cell
        actors = []
        colors = [
            "#ff7f50", "#4682b4", "#6b8e23", "#d2691e", "#5f9ea0", "#8fbc8f",
            "#6495ed"
        ]
        radii = [(0.1 + 0.004 * i) * min(lattice.lengths)
                 for i in range(len(colors))]
        res = 50

        for atom_index, atom_name in enumerate(atoms.keys()):
            radius = radii[atom_index]
            color = self.hex_to_rgb(colors[atom_index])
            for atom in atoms[atom_name]:
                polyDataSource = vtk.vtkSphereSource()
                polyDataSource.SetRadius(radius)
                polyDataSource.SetPhiResolution(res)
                polyDataSource.SetThetaResolution(res)
                polyDataSource.SetCenter(*lattice.get_cartesian_coords(atom))

                transform = vtk.vtkTransform()
                wxyz = np.identity(4)
                wxyz[0:3, 3] = -lattice.get_cartesian_coords([0.5, 0.5, 0.5])
                m = vtk.vtkMatrix4x4()
                m.DeepCopy(wxyz.ravel())
                transform.SetMatrix(m)
                transformPD = vtk.vtkTransformPolyDataFilter()
                transformPD.SetTransform(transform)
                transformPD.SetInputConnection(polyDataSource.GetOutputPort())

                mapper = vtk.vtkPolyDataMapper()
                mapper.SetInputConnection(transformPD.GetOutputPort())
                actor = vtk.vtkActor()
                actor.SetMapper(mapper)
                actor.GetProperty().SetColor(color)
                actor.GetProperty().SetAmbient(0.35)
                actor.GetProperty().SetDiffuse(0.55)
                actor.GetProperty().SetSpecular(0.5)
                actor.GetProperty().SetSpecularPower(7.0)
                actors.append(actor)
        return actors
示例#46
0
def add_map(config):
    """
    Loads vtk models from a directory and returns
    a list of vtk actors, with mesh visualisation

    :param: configuration, may contain a "map" key
    :param: model_to_world: 4x4 matrix, of dtype float32

    :return: actors, None if no "map" key
    """
    models = []
    if "map" not in config:
        return None

    path_name = config.get("map")

    loader = VTKSurfaceModelDirectoryLoader(path_name)
    models = loader.models

    model_to_world = _set_model_to_world(config)
    transform = vtk.vtkTransform()
    transform.SetMatrix(np2vtk(model_to_world))

    for model in models:
        transformer = vtk.vtkTransformPolyDataFilter()
        transformer.SetTransform(transform)
        transformer.SetInputData(model.source)
        target = vtk.vtkPolyData()
        transformer.SetOutput(target)
        transformer.Update()
        model.source = target

        transformer.SetInputConnection(model.normals.GetOutputPort())
        model.mapper = vtk.vtkPolyDataMapper()
        model.mapper.SetInputConnection(transformer.GetOutputPort())
        model.mapper.Update()
        model.actor.SetMapper(model.mapper)
        model.actor.GetProperty().SetRepresentationToWireframe()
        model.actor.GetProperty().SetColor(0.7, 0.7, 0.7)
        model.actor.GetProperty().SetOpacity(1.0)
        model.actor.GetProperty().SetBackfaceCulling(False)

    return models
    def __init__(self,
                 height,
                 radius,
                 colour,
                 name,
                 visibility=True,
                 opacity=1.0):
        """
        Creates a new surface model.

        :param height: the height of the cone
        :param diameter: the radius of the cone
        :param name: a name for the model
        :param colour: (R,G,B) where each are floats [0-1]
        :param visibility: boolean, True|False
        :param opacity: float [0,1]
        """

        super().__init__(None, colour, visibility, opacity)
        self.name = name

        cone = vtk.vtkConeSource()
        cone.SetResolution(88)
        cone.SetRadius(radius)
        cone.SetHeight(height)
        cone.Update()
        self.source = cone.GetOutput()

        #this is from super init, have to redo as we now have data
        self.normals = None
        self.normals = vtk.vtkPolyDataNormals()
        self.normals.SetInputData(self.source)
        self.normals.SetAutoOrientNormals(True)
        self.normals.SetFlipNormals(False)
        self.transform = vtk.vtkTransform()
        self.transform.Identity()
        self.transform_filter = vtk.vtkTransformPolyDataFilter()
        self.transform_filter.SetInputConnection(self.normals.GetOutputPort())
        self.transform_filter.SetTransform(self.transform)
        self.mapper = vtk.vtkPolyDataMapper()
        self.mapper.SetInputConnection(self.transform_filter.GetOutputPort())
        self.mapper.Update()
        self.actor.SetMapper(self.mapper)
def add_contour(renderer,
                plane,
                polydata,
                transform=None,
                line_width=3,
                color=(1, 0, 0)):
    """Add contour of mesh cut by given image plane to render scene."""
    if transform:
        transformer = vtk.vtkTransformPolyDataFilter()
        transformer.SetInputData(polydata)
        transformer.SetTransform(transform)
        transformer.Update()
        polydata = deep_copy(transformer.GetOutput())
        transformer = None
    cutter = vtk.vtkCutter()
    cutter.SetInputData(polydata)
    cutter.SetCutFunction(plane)
    cutter.Update()
    contour = deep_copy(cutter.GetOutput())
    cutter = None

    mapper = vtk.vtkPolyDataMapper()
    mapper.SetInputData(contour)

    actor = vtk.vtkActor()
    actor.SetMapper(mapper)
    prop = actor.GetProperty()
    prop.LightingOff()
    prop.SetRepresentationToWireframe()
    prop.SetLineWidth(line_width)

    if color:
        prop.SetColor(color)
        mapper.ScalarVisibilityOff()
    elif polydata.GetPointData().GetScalars():
        mapper.SetScalarModeToUsePointData()
        mapper.ScalarVisibilityOn()
    elif polydata.GetCellData().GetScalars():
        mapper.SetScalarModeToUseCellData()
        mapper.ScalarVisibilityOn()

    renderer.AddActor(actor)
    return actor
示例#49
0
    def __init__(self, center=(0, 0, 0), color=(0, 0, 1), rotXYZ=(0, 0, 0)):
        """ arrow """
        self.src = vtk.vtkArrowSource()
        #self.src.SetCenter(center)

        transform = vtk.vtkTransform()
        transform.Translate(center[0], center[1], center[2])
        transform.RotateX(rotXYZ[0])
        transform.RotateY(rotXYZ[1])
        transform.RotateZ(rotXYZ[2])
        transformFilter = vtk.vtkTransformPolyDataFilter()
        transformFilter.SetTransform(transform)
        transformFilter.SetInputConnection(self.src.GetOutputPort())
        transformFilter.Update()

        self.mapper = vtk.vtkPolyDataMapper()
        self.mapper.SetInputConnection(transformFilter.GetOutputPort())
        self.SetMapper(self.mapper)
        self.SetColor(color)
示例#50
0
    def __init__(self, text="test", color=cyan, center=(0, 0, 0), scale=1):
        self.textSource = vtk.vtkVectorText()
        self.textSource.SetText(text)
        self.scale = scale

        self.transform = vtk.vtkTransform()

        self.transform.Translate(center[0], center[1], center[2])
        self.transform.Scale(self.scale, self.scale, self.scale)
        self.transformFilter = vtk.vtkTransformPolyDataFilter()
        self.transformFilter.SetTransform(self.transform)
        self.transformFilter.SetInputConnection(
            self.textSource.GetOutputPort())
        self.transformFilter.Update()

        self.mapper = vtk.vtkPolyDataMapper()
        self.mapper.SetInputConnection(self.transformFilter.GetOutputPort())
        self.SetMapper(self.mapper)
        self.SetColor(color)
示例#51
0
    def applyTPSTransform(self, sourcePoints, targetPoints, modelNode,
                          nodeName):
        transform = vtk.vtkThinPlateSplineTransform()
        transform.SetSourceLandmarks(sourcePoints)
        transform.SetTargetLandmarks(targetPoints)
        transform.SetBasisToR()  # for 3D transform

        transformFilter = vtk.vtkTransformPolyDataFilter()
        transformFilter.SetInputData(modelNode.GetPolyData())
        transformFilter.SetTransform(transform)
        transformFilter.Update()

        warpedPolyData = transformFilter.GetOutput()
        warpedModelNode = slicer.mrmlScene.AddNewNodeByClass(
            'vtkMRMLModelNode', nodeName)
        warpedModelNode.CreateDefaultDisplayNodes()
        warpedModelNode.SetAndObservePolyData(warpedPolyData)
        #self.RAS2LPSTransform(warpedModelNode)
        return warpedModelNode
示例#52
0
 def transform_fiber_array_NOT_USED(self, in_array, transform):
     """Transform in_array (of class FiberArray) by transform (9
     components, rotation about R,A,S, translation in R, A, S, and
     scale along R, A, S. Fibers are assumed to be in RAS.  Transformed
     fibers are returned."""
     
     out_array = whitematteranalysis.fibers.FiberArray()
     pd_in = in_array.convert_to_polydata()
     transformer = vtk.vtkTransformPolyDataFilter()
     if (vtk.vtkVersion().GetVTKMajorVersion() >= 6.0):
         transformer.SetInputData(pd_in)
     else:
         transformer.SetInput(pd_in) 
     vtktrans = self.convert_transform_to_vtk(transform)
     transformer.SetTransform(vtktrans)
     transformer.Update()
     pd_out = transformer.GetOutput()
     out_array.convert_from_polydata(pd_out, self.points_per_fiber)
     return out_array
示例#53
0
    def makeZCutter(self, bounds, scaleFactor, value):
        """ create z cutter plane """

        npos = self._calculateZCutterPos(value)
        self.zplane = vtk.vtkPlane()
        self.zplane.SetOrigin(0, 0, npos)
        self.zplane.SetNormal(0, 0, 1)

        self.ZCutter = vtk.vtkCutter()
        self.ZCutter.SetInputConnection(self.warp.GetOutputPort())
        self.ZCutter.SetCutFunction(self.zplane)
        self.ZCutter.GenerateCutScalarsOff()

        self.ZCutterMapper = vtk.vtkPolyDataMapper()
        self.ZCutterMapper.SetInputConnection(self.ZCutter.GetOutputPort())

        # visual plane to move
        plane = vtk.vtkPlaneSource()
        plane.SetResolution(50, 50)
        plane.SetCenter(0, 0, 0)
        plane.SetNormal(0, 0, 1)

        tran = vtk.vtkTransform()
        tran.Translate((bounds[1] - bounds[0]) / 2. - (0 - bounds[0]), (bounds[3] - bounds[2]) / 2. - (0 - bounds[2]),
                       npos)
        tran.Scale((bounds[1] - bounds[0]), (bounds[3] - bounds[2]), 1)
        tran.PostMultiply()

        self.ZCutterTransform = tran

        tranf = vtk.vtkTransformPolyDataFilter()
        tranf.SetInputConnection(plane.GetOutputPort())
        tranf.SetTransform(tran)

        mapper = vtk.vtkPolyDataMapper()
        mapper.SetInputConnection(tranf.GetOutputPort())

        actor = vtk.vtkActor()
        actor.SetMapper(mapper)
        actor.GetProperty().SetColor(0.9, 0.9, 0.9)
        actor.GetProperty().SetOpacity(self.opacitySlice)

        return actor
示例#54
0
def Alignement(surf,surf_GT):
	print('Alignement ')
	# CenterSurf = surf.GetCenter()
	# print("center CenterSurf: ", CenterSurf)
	# print(' ')
	# CenterSurf_GT = surf_GT.GetCenter()
	# print("center CenterSurf_GT: ", CenterSurf_GT)
	# print(' ')
	# direction = np.array(list(surf_GT.GetCenter())) - np.array(list(surf.GetCenter()))
	# print('direction = ', direction)
	# print(' ')

	# trnf = vtk.vtkTransform()
	# trnf.Translate(direction)

	# tpd = vtk.vtkTransformPolyDataFilter()
	# tpd.SetTransform(trnf)
	# tpd.SetInputData(surf)
	# tpd.Update()

	# return tpd.GetOutput()


	icp = vtk.vtkIterativeClosestPointTransform()
	icp.StartByMatchingCentroidsOn()
	icp.SetSource(surf)
	icp.SetTarget(surf_GT)
	icp.GetLandmarkTransform().SetModeToRigidBody()
	icp.SetMaximumNumberOfLandmarks(100)
	icp.SetMaximumMeanDistance(.00001)
	icp.SetMaximumNumberOfIterations(500)
	icp.CheckMeanDistanceOn()
	icp.StartByMatchingCentroidsOn()
	icp.Update()

	lmTransform = icp.GetLandmarkTransform()
	transform = vtk.vtkTransformPolyDataFilter()
	transform.SetInputData(surf)
	transform.SetTransform(lmTransform)
	transform.SetTransform(icp)
	transform.Update()

	return transform.GetOutput()
示例#55
0
    def __init__(self, marker, planeWidget, transform=None, lineWidth=1):

        self.marker = marker
        self.markerSource = marker.get_source()
        self.planeWidget = planeWidget
        self.transform = transform

        self.implicitPlane = vtk.vtkPlane()
        self.ringEdges = vtk.vtkCutter()
        self.ringStrips = vtk.vtkStripper()
        self.ringPoly = vtk.vtkPolyData()
        self.ringMapper = vtk.vtkPolyDataMapper()

        self.ringEdges.SetInput(self.markerSource.GetOutput())
        self.implicitPlane.SetNormal(self.planeWidget.GetNormal())
        self.implicitPlane.SetOrigin(self.planeWidget.GetOrigin())

        #print 'implicit plane', self.implicitPlane
        self.ringEdges.SetCutFunction(self.implicitPlane)
        self.ringEdges.GenerateCutScalarsOff()
        self.ringEdges.SetValue(0, 0.0)
        self.ringStrips.SetInput(self.ringEdges.GetOutput())
        self.ringStrips.Update()
        self.ringPoly.SetPoints(self.ringStrips.GetOutput().GetPoints())
        self.ringPoly.SetPolys(self.ringStrips.GetOutput().GetLines())
        self.ringMapper.SetInput(self.ringPoly)
        self.SetMapper(self.ringMapper)

        self.lineProperty = self.GetProperty()
        self.lineProperty.SetRepresentationToWireframe()
        self.lineProperty.SetAmbient(1.0)
        self.lineProperty.SetColor(self.marker.get_color())
        self.lineProperty.SetLineWidth(lineWidth)

        self.SetProperty(self.lineProperty)
        self.VisibilityOff()

        if transform is not None:
            self.filter = vtk.vtkTransformPolyDataFilter()
            self.filter.SetTransform(transform)
        else:
            self.filter = None
        self.update()
示例#56
0
def Arrows(startPoints, endPoints=None, s=None, c="r", alpha=1, res=8):
    """
    Build arrows between two lists of points `startPoints` and `endPoints`.
    `startPoints` can be also passed in the form ``[[point1, point2], ...]``.
    """
    if endPoints is not None:
        startPoints = list(zip(startPoints, endPoints))

    polyapp = vtk.vtkAppendPolyData()
    for twopts in startPoints:
        startPoint, endPoint = twopts
        axis = np.array(endPoint) - np.array(startPoint)
        length = np.linalg.norm(axis)
        if length:
            axis = axis / length
        theta = np.arccos(axis[2])
        phi = np.arctan2(axis[1], axis[0])
        arr = vtk.vtkArrowSource()
        arr.SetShaftResolution(res)
        arr.SetTipResolution(res)
        if s:
            sz = 0.02
            arr.SetTipRadius(sz)
            arr.SetShaftRadius(sz / 1.75)
            arr.SetTipLength(sz * 15)
        t = vtk.vtkTransform()
        t.Translate(startPoint)
        t.RotateZ(phi * 57.3)
        t.RotateY(theta * 57.3)
        t.RotateY(-90)  # put it along Z
        if s:
            sz = 800.0 * s
            t.Scale(length, sz, sz)
        else:
            t.Scale(length, length, length)
        tf = vtk.vtkTransformPolyDataFilter()
        tf.SetInputConnection(arr.GetOutputPort())
        tf.SetTransform(t)
        polyapp.AddInputConnection(tf.GetOutputPort())

    polyapp.Update()
    actor = Actor(polyapp.GetOutput(), c, alpha)
    return actor
示例#57
0
def AlignBoundingBoxes(source, target):
    # Use OBBTree to create an oriented bounding box for target and source
    sourceOBBTree = vtk.vtkOBBTree()
    sourceOBBTree.SetDataSet(source)
    sourceOBBTree.SetMaxLevel(1)
    sourceOBBTree.BuildLocator()

    targetOBBTree = vtk.vtkOBBTree()
    targetOBBTree.SetDataSet(target)
    targetOBBTree.SetMaxLevel(1)
    targetOBBTree.BuildLocator()

    sourceLandmarks = vtk.vtkPolyData()
    sourceOBBTree.GenerateRepresentation(0, sourceLandmarks)

    targetLandmarks = vtk.vtkPolyData()
    targetOBBTree.GenerateRepresentation(0, targetLandmarks)

    lmTransform = vtk.vtkLandmarkTransform()
    lmTransform.SetModeToSimilarity()
    lmTransform.SetTargetLandmarks(targetLandmarks.GetPoints())
    # lmTransformPD = vtk.vtkTransformPolyDataFilter()
    bestDistance = vtk.VTK_DOUBLE_MAX
    bestPoints = vtk.vtkPoints()
    bestDistance = BestBoundingBox("X", target, source, targetLandmarks,
                                   sourceLandmarks, bestDistance, bestPoints)
    bestDistance = BestBoundingBox("Y", target, source, targetLandmarks,
                                   sourceLandmarks, bestDistance, bestPoints)
    bestDistance = BestBoundingBox("Z", target, source, targetLandmarks,
                                   sourceLandmarks, bestDistance, bestPoints)

    lmTransform.SetSourceLandmarks(bestPoints)
    lmTransform.Modified()

    transformPD = vtk.vtkTransformPolyDataFilter()
    transformPD.SetInputData(source)
    transformPD.SetTransform(lmTransform)
    transformPD.Update()

    source.DeepCopy(transformPD.GetOutput())

    return
def plane(pos=[0, 0, 0],
          normal=[0, 0, 1],
          sx=1,
          sy=None,
          c='g',
          bc='darkgreen',
          alpha=1,
          legend=None,
          texture=None):
    '''
    Draw a plane of size sx and sy oriented perpendicular to vector normal  
    and so that it passes through point pos.
    '''
    if sy is None: sy = sx
    ps = vtk.vtkPlaneSource()
    ps.SetResolution(1, 1)
    tri = vtk.vtkTriangleFilter()
    tri.SetInputConnection(ps.GetOutputPort())
    tri.Update()
    poly = tri.GetOutput()
    axis = np.array(normal) / np.linalg.norm(normal)
    theta = np.arccos(axis[2])
    phi = np.arctan2(axis[1], axis[0])
    t = vtk.vtkTransform()
    t.PostMultiply()
    t.Scale(sx, sy, 1)
    t.RotateY(theta * 57.3)
    t.RotateZ(phi * 57.3)
    tf = vtk.vtkTransformPolyDataFilter()
    vu.setInput(tf, poly)
    tf.SetTransform(t)
    tf.Update()
    pd = tf.GetOutput()
    actor = vu.makeActor(pd,
                         c=c,
                         bc=bc,
                         alpha=alpha,
                         legend=legend,
                         texture=texture)
    actor.SetPosition(pos)
    actor.PickableOff()
    return actor
示例#59
0
    def Execute(self):

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

        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.vtkTransformPolyDataFilter()
        transformFilter.SetInput(self.Surface)
        transformFilter.SetTransform(transform)
        transformFilter.Update()

        self.Surface = transformFilter.GetOutput()

        if self.Surface.GetSource():
            self.Surface.GetSource().UnRegisterAllOutputs()
        def makeHandle():
            fn = vtk.vtkParametricTorus()
            fn.SetRingRadius((rightBound - leftBound) / 5)
            fn.SetCrossSectionRadius((rightBound - leftBound) / 15)
            #vtk.FlipNormalsOn()
            source = vtk.vtkParametricFunctionSource()
            source.SetParametricFunction(fn)
            source.Update()

            trans = vtk.vtkTransform()
            trans.RotateX(90)
            trans.Translate(midline, topBound + 5, halfway)
            # vtk generate normals
            # communicate with SLACK
            rotate = vtk.vtkTransformPolyDataFilter()
            rotate.SetTransform(trans)
            rotate.SetInputConnection(source.GetOutputPort())
            rotate.Update()

            return rotate.GetOutput()