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)
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
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
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)
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)
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')
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
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)
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
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
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()
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)
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)
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)
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
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
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])
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()
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 addContourObject(self, contourObject, prop3D): """Activate contouring for the contourObject. The contourObject is usually a tdObject and specifically a vtkPolyData. We also need the prop3D that represents this polydata in the 3d scene. """ if self._contourObjectsDict.has_key(contourObject): # we already have this, thanks return try: contourable = contourObject.IsA('vtkPolyData') except: contourable = False if contourable: # we need a cutter to calculate the contours and then a stripper # to string them all together cutter = vtk.vtkCutter() plane = vtk.vtkPlane() cutter.SetCutFunction(plane) trfm = vtk.vtkTransform() trfm.SetMatrix(prop3D.GetMatrix()) trfmFilter = vtk.vtkTransformPolyDataFilter() trfmFilter.SetTransform(trfm) trfmFilter.SetInput(contourObject) cutter.SetInput(trfmFilter.GetOutput()) stripper = vtk.vtkStripper() stripper.SetInput(cutter.GetOutput()) # #tubef = vtk.vtkTubeFilter() #tubef.SetNumberOfSides(12) #tubef.SetRadius(0.5) #tubef.SetInput(stripper.GetOutput()) # and create the overlay at least for the 3d renderer mapper = vtk.vtkPolyDataMapper() mapper.SetInput(stripper.GetOutput()) mapper.ScalarVisibilityOff() actor = vtk.vtkActor() actor.SetMapper(mapper) c = self.sliceDirections.slice3dVWR._tdObjects.getObjectColour( contourObject) actor.GetProperty().SetColor(c) actor.GetProperty().SetInterpolationToFlat() # add it to the renderer self.sliceDirections.slice3dVWR._threedRenderer.AddActor(actor) # add all necessary metadata to our dict contourDict = {'contourObject' : contourObject, 'contourObjectProp' : prop3D, 'trfmFilter' : trfmFilter, 'cutter' : cutter, 'tdActor' : actor} self._contourObjectsDict[contourObject] = contourDict # now sync the bugger self.syncContourToObject(contourObject)
def 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();
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
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
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()
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()
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()
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
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
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()
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()
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()
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())
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()
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
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
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
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)
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)
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
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
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
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()
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()
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
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
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()