def display(data, data2=None, data3=None): # Generate some random points math = vtk.vtkMath() points = vtk.vtkPoints() [data, scalefactor]=scaledata(data) for i in range(len(data)): points.InsertNextPoint( data[i,0],data[i,1], data[i,2]); ballActor = vtksetup(points, color=red, radius=.001) [ren,renWin,iren]=vtkwindow() ren.AddActor(ballActor) # Add the actors to the renderer, set the background and size if data2 != None: data=data2*scalefactor points = vtk.vtkPoints() for i in range(len(data)): points.InsertNextPoint( data[i,0],data[i,1], data[i,2]); ballActor = vtksetup(points, color=blue) ren.AddActor(ballActor) if data3 != None: data=data3*scalefactor points = vtk.vtkPoints() for i in range(len(data)): points.InsertNextPoint( data[i,0],data[i,1], data[i,2]); ballActor = vtksetup(points, color=green, radius=.007) ren.AddActor(ballActor) # Interact with the data. iren.Initialize() renWin.Render() iren.Start()
def latitude_create( arg_lat, arg_projection): if arg_projection == 'linear' : n_polypoints=2 polygonpoints=vtk.vtkPoints() polygonpoints.SetNumberOfPoints(n_polypoints) polygonpoints.InsertPoint(0,-180,arg_lat,0) polygonpoints.InsertPoint(1,540,arg_lat,0) else: n_polypoints=360 polygonpoints=vtk.vtkPoints() polygonpoints.SetNumberOfPoints(n_polypoints) deg2rad=numpy.pi/180. for n in range(n_polypoints) : theta=2*numpy.pi*n/(n_polypoints-1) x=numpy.cos(arg_lat*deg2rad)*numpy.cos(theta) y=numpy.cos(arg_lat*deg2rad)*numpy.sin(theta) z=numpy.sin(arg_lat*deg2rad) polygonpoints.InsertPoint(n,x,y,z) polygonlines=vtk.vtkCellArray() polygonlines.InsertNextCell(n_polypoints) for n in range(n_polypoints) : polygonlines.InsertCellPoint(n) latpolydata=vtk.vtkPolyData() latpolydata.SetPoints(polygonpoints) latpolydata.SetLines(polygonlines) return latpolydata
def getRigidTransform(fix, mov): # In real resolution LandmarkTransform = vtk.vtkLandmarkTransform() LandmarkTransform.SetModeToRigidBody() n = fix.shape[0] fix_point = vtk.vtkPoints() fix_point.SetNumberOfPoints(n) mov_point = vtk.vtkPoints() mov_point.SetNumberOfPoints(n) for i in range(n): fix_point.SetPoint(i, fix[i, 0], fix[i, 1], fix[i, 2]) mov_point.SetPoint(i, mov[i, 0], mov[i, 1], mov[i, 2]) LandmarkTransform.SetSourceLandmarks(mov_point) LandmarkTransform.SetTargetLandmarks(fix_point) LandmarkTransform.Update() matrix = LandmarkTransform.GetMatrix() T = ml.zeros([4, 4], dtype = npy.float32) for i in range(4): for j in range(4): T[i, j] = matrix.GetElement(j, i) p1 = mov[0, :].tolist() p2 = [0.0, 0, 0] LandmarkTransform.InternalTransformPoint(p1, p2) return T, npy.array(p2)
def __init__(self, sliceWidget): # keep a flag since events such as sliceNode modified # may come during superclass construction, which will # invoke our processEvents method self.initialized = False super(DrawEffectTool,self).__init__(sliceWidget) # create a logic instance to do the non-gui work self.logic = DrawEffectLogic(self.sliceWidget.sliceLogic()) # interaction state variables self.activeSlice = None self.lastInsertSLiceNodeMTime = None self.actionState = None # initialization self.xyPoints = vtk.vtkPoints() self.rasPoints = vtk.vtkPoints() self.polyData = self.createPolyData() self.mapper = vtk.vtkPolyDataMapper2D() self.actor = vtk.vtkActor2D() self.mapper.SetInputData(self.polyData) self.actor.SetMapper(self.mapper) property_ = self.actor.GetProperty() property_.SetColor(1,1,0) property_.SetLineWidth(1) self.renderer.AddActor2D( self.actor ) self.actors.append( self.actor ) self.initialized = True
def __init__(self, sliceWidget): super(LevelTracingEffectTool,self).__init__(sliceWidget) # create a logic instance to do the non-gui work self.logic = LevelTracingEffectLogic(self.sliceWidget.sliceLogic()) # instance variables self.actionState = '' # initialization self.xyPoints = vtk.vtkPoints() self.rasPoints = vtk.vtkPoints() self.polyData = vtk.vtkPolyData() self.tracingFilter = vtkITK.vtkITKLevelTracingImageFilter() self.ijkToXY = vtk.vtkGeneralTransform() self.mapper = vtk.vtkPolyDataMapper2D() self.actor = vtk.vtkActor2D() property_ = self.actor.GetProperty() property_.SetColor( 107/255., 190/255., 99/255. ) property_.SetLineWidth( 1 ) if vtk.VTK_MAJOR_VERSION <= 5: self.mapper.SetInput(self.polyData) else: self.mapper.SetInputData(self.polyData) self.actor.SetMapper(self.mapper) property_ = self.actor.GetProperty() property_.SetColor(1,1,0) property_.SetLineWidth(1) self.renderer.AddActor2D( self.actor ) self.actors.append( self.actor )
def genTextActor(renderer,string=None,x=None,y=None,to='default',tt='default',cmap=None): if isinstance(to,str): to = vcs.elements["textorientation"][to] if isinstance(tt,str): tt = vcs.elements["texttable"][tt] if tt.priority==0: return [] if string is None: string = tt.string if x is None: x = tt.x if y is None: y = tt.y if x is None or y is None or string in [['',],[]]: return [] n = max(len(x),len(y),len(string)) for a in [x,y,string]: while len(a)<n: a.append(a[-1]) sz = renderer.GetRenderWindow().GetSize() actors=[] pts = vtk.vtkPoints() geo = None if vcs.elements["projection"][tt.projection].type!="linear": # Need to figure out new WC Npts = 20 for i in range(Npts+1): X = tt.worldcoordinate[0]+float(i)/Npts*(tt.worldcoordinate[1]-tt.worldcoordinate[0]) for j in range(Npts+1): Y = tt.worldcoordinate[2]+float(j)/Npts*(tt.worldcoordinate[3]-tt.worldcoordinate[2]) pts.InsertNextPoint(X,Y,0.) geo,pts = project(pts,tt.projection,tt.worldcoordinate,geo=None) wc = pts.GetBounds()[:4] #renderer.SetViewport(tt.viewport[0],tt.viewport[2],tt.viewport[1],tt.viewport[3]) renderer.SetWorldPoint(wc) for i in range(n): t = vtk.vtkTextActor() p=t.GetTextProperty() prepTextProperty(p,sz,to,tt,cmap) pts = vtk.vtkPoints() pts.InsertNextPoint(x[i],y[i],0.) if geo is not None: geo,pts = project(pts,tt.projection,tt.worldcoordinate,geo=geo) X,Y,tz=pts.GetPoint(0) X,Y = world2Renderer(renderer,X,Y,tt.viewport,wc) else: X,Y = world2Renderer(renderer,x[i],y[i],tt.viewport,tt.worldcoordinate) t.SetPosition(X,Y) t.SetInput(string[i]) #T=vtk.vtkTransform() #T.Scale(1.,sz[1]/606.,1.) #T.RotateY(to.angle) #t.SetUserTransform(T) renderer.AddActor(t) actors.append(t) return actors
def setPointHeights( self, ptheights ): try: if self.topo == PlotType.Planar: self.np_points_data[2::3] = ptheights vtk_points_data = numpy_support.numpy_to_vtk( self.np_points_data ) vtk_points_data.SetNumberOfComponents( 3 ) vtk_points_data.SetNumberOfTuples( len( self.np_points_data ) / 3 ) self.vtk_planar_points.SetData( vtk_points_data ) self.polydata.SetPoints( self.vtk_planar_points ) self.vtk_planar_points.Modified() elif self.topo == PlotType.Spherical: self.np_sp_grid_data[0::3] = self.spherical_scaling * ptheights + self.earth_radius vtk_sp_grid_data = numpy_support.numpy_to_vtk( self.np_sp_grid_data ) size = vtk_sp_grid_data.GetSize() vtk_sp_grid_data.SetNumberOfComponents( 3 ) vtk_sp_grid_data.SetNumberOfTuples( size/3 ) vtk_sp_grid_points = vtk.vtkPoints() vtk_sp_grid_points.SetData( vtk_sp_grid_data ) self.vtk_spherical_points = vtk.vtkPoints() self.shperical_to_xyz_trans.TransformPoints( vtk_sp_grid_points, self.vtk_spherical_points ) # pt0 = self.vtk_spherical_points.GetPoint(0) # print "VTK Set point Heights, samples: %s %s %s " % ( str( ptheights[0] ), str( self.np_sp_grid_data[0] ), str( pt0 ) ) self.polydata.SetPoints( self.vtk_spherical_points ) self.vtk_spherical_points.Modified() self.polydata.Modified() except Exception, err: self.printLogMessage( "Processing point heights: %s " % str( err ), error=True )
def computeSphericalPoints( self, **args ): lon_data = self.np_points_data[0::3] lat_data = self.np_points_data[1::3] z_data = self.np_points_data[2::3] radian_scaling = math.pi / 180.0 theta = ( 90.0 - lat_data ) * radian_scaling phi = lon_data * radian_scaling r = z_data * self.spherical_scaling + self.earth_radius self.np_sp_grid_data = numpy.dstack( ( r, theta, phi ) ).flatten() vtk_sp_grid_data = numpy_support.numpy_to_vtk( self.np_sp_grid_data ) # if self.grid == PlotType.List: # # r = numpy.empty( lon_data.shape, lon_data.dtype ) # # r.fill( self.earth_radius ) # r = z_data * self.spherical_scaling + self.earth_radius # self.np_sp_grid_data = numpy.dstack( ( r, theta, phi ) ).flatten() # vtk_sp_grid_data = numpy_support.numpy_to_vtk( self.np_sp_grid_data ) # elif self.grid == PlotType.Grid: # thetaB = theta.reshape( [ theta.shape[0], 1 ] ) # phiB = phi.reshape( [ 1, phi.shape[0] ] ) # grid_data = numpy.array( [ ( self.earth_radius, t, p ) for (t,p) in numpy.broadcast(thetaB,phiB) ] ) # self.np_sp_grid_data = grid_data.flatten() # vtk_sp_grid_data = numpy_support.numpy_to_vtk( self.np_sp_grid_data ) # else: # print>>sys.stderr, "Unrecognized grid type: %s " % str( self.grid ) # return size = vtk_sp_grid_data.GetSize() vtk_sp_grid_data.SetNumberOfComponents( 3 ) vtk_sp_grid_data.SetNumberOfTuples( size/3 ) vtk_sp_grid_points = vtk.vtkPoints() vtk_sp_grid_points.SetData( vtk_sp_grid_data ) self.vtk_spherical_points = vtk.vtkPoints() self.shperical_to_xyz_trans.TransformPoints( vtk_sp_grid_points, self.vtk_spherical_points )
def __init__(self): pypes.pypeScript.__init__(self) self.Surface = None self.DeformedSurface = None self.SourcePoints = vtk.vtkPoints() self.TargetPoints = vtk.vtkPoints() self.DisplacementNorms = vtk.vtkDoubleArray() self.Displacements = vtk.vtkDoubleArray() self.Displacements.SetNumberOfComponents(3) self.SourceSpheres = vtk.vtkPolyData() self.TargetSpheres = vtk.vtkPolyData() self.SourceSpheres.SetPoints(self.SourcePoints) self.TargetSpheres.SetPoints(self.TargetPoints) self.SourceSpheres.GetPointData().SetScalars(self.DisplacementNorms) self.SourceSpheres.GetPointData().SetVectors(self.Displacements) self.vmtkRenderer = None self.OwnRenderer = 0 self.DisplayDeformed = False self.SurfaceMapper = None self.Opacity = 1.0 self.SourceSpheresActor = None self.TargetSpheresActor = None self.SetScriptName("vmtkthinplatesplinedeformation") self.SetInputMembers( [ ["Surface", "i", "vtkPolyData", 1, "", "the input surface", "vmtksurfacereader"], ["Opacity", "opacity", "float", 1, "(0.0,1.0)", "object opacities in the scene"], ["vmtkRenderer", "renderer", "vmtkRenderer", 1, "", "external renderer"], ] ) self.SetOutputMembers([["DeformedSurface", "o", "vtkPolyData", 1, "", "", "vmtksurfacewriter"]])
def DeleteCallback(self, obj): delId = -1 sourceValid = False if self.CurrentSourcePointId != -1: delId = self.CurrentSourcePointId sourceValid = True elif self.CurrentTargetPointId != -1: delId = self.CurrentTargetPointId else: return savedSources = vtk.vtkPoints() savedSources.DeepCopy(self.SourcePoints) savedTargets = vtk.vtkPoints() savedTargets.DeepCopy(self.TargetPoints) self.InitializeSpheres() for i in range(savedSources.GetNumberOfPoints()): if i != delId: self.AddDisplacement(savedSources.GetPoint(i), savedTargets.GetPoint(i)) nPoints = self.SourcePoints.GetNumberOfPoints() if nPoints == 0: self.SelectSource(-1) elif sourceValid: self.SelectSource((delId - 1) % nPoints) else: self.SelectTarget((delId - 1) % nPoints) self.SourceSpheres.Modified() self.TargetSpheres.Modified() self.vmtkRenderer.RenderWindow.Render()
def method(self): # multiblock += contact points output_a = self._contact_source_a.GetPolyDataOutput() output_b = self._contact_source_b.GetPolyDataOutput() id_f = numpy.where( abs(self._data[:, 0] - self._time) < 1e-15)[0] self.cpa_export = self._data[ id_f, 2:5].copy() self.cpb_export = self._data[ id_f, 5:8].copy() self.cn_export = self._data[ id_f, 8:11].copy() self.cf_export = self._data[ id_f, 11:14].copy() self.cpa_ = numpy_support.numpy_to_vtk( self.cpa_export) self.cpa_.SetName('contact_positions_A') self.cpb_ = numpy_support.numpy_to_vtk( self.cpb_export) self.cpb_.SetName('contact_positions_B') self.cn_ = numpy_support.numpy_to_vtk( self.cn_export) self.cn_.SetName('contact_normals') self.cf_ = numpy_support.numpy_to_vtk( self.cf_export) self.cf_.SetName('contact_forces') output_a.Allocate(len(self.cpa_export), 1) cpa_points = vtk.vtkPoints() cpa_points.SetNumberOfPoints(len(self.cpa_export)) cpa_points.SetData(self.cpa_) output_a.SetPoints(cpa_points) # normal and forces are attached to A points output_a.GetPointData().AddArray(self.cn_) output_a.GetPointData().AddArray(self.cf_) output_b.Allocate(len(self.cpb_export), 1) cpb_points = vtk.vtkPoints() cpb_points.SetNumberOfPoints(len(self.cpb_export)) cpb_points.SetData(self.cpb_) output_b.SetPoints(cpb_points)
def KeyPressCallback(self, obj, event): ch = self.window_interactor.GetKeySym() if ch == 'Return': trans = loadTransform() num = 0 for transform in trans: self.point_data_result = applyTransform(self.tmp_data_move, transform) self.point_data_result[:, :3] /= self.tmp_space for cnt in range(3, 6): point_result = self.point_data_result[npy.where(npy.round(self.point_data_result[:, -1]) == cnt - 3)] point_move = self.point_data_move[npy.where(npy.round(self.point_data_move[:, -1]) == cnt - 3)] if not point_result.shape[0]: continue self.cells = vtk.vtkCellArray() self.points = vtk.vtkPoints() l = 0 for i in range(self.zmin, self.zmax + 1): data = point_result[npy.where(npy.round(point_move[:, 2]) == i)] if data is not None: if data.shape[0] == 0: continue count = data.shape[0] points = vtk.vtkPoints() for j in range(count): points.InsertPoint(j, data[j, 0], data[j, 1], data[j, 2]) para_spline = vtk.vtkParametricSpline() para_spline.SetXSpline(vtk.vtkKochanekSpline()) para_spline.SetYSpline(vtk.vtkKochanekSpline()) para_spline.SetZSpline(vtk.vtkKochanekSpline()) para_spline.SetPoints(points) para_spline.ClosedOn() # The number of output points set to 10 times of input points numberOfOutputPoints = count * 10 self.cells.InsertNextCell(numberOfOutputPoints) for k in range(0, numberOfOutputPoints): t = k * 1.0 / numberOfOutputPoints pt = [0.0, 0.0, 0.0] para_spline.Evaluate([t, t, t], pt, [0] * 9) if pt[0] != pt[0]: print pt continue self.points.InsertPoint(l, pt[0], pt[1], pt[2]) self.cells.InsertCellPoint(l) l += 1 self.contours[cnt].SetPoints(self.points) self.contours[cnt].SetPolys(self.cells) self.contours[cnt].Update() self.render_window.Render() saveGif(self.render_window, num) num += 1
def draw_lines(nodes, color): colors = vtk.vtkUnsignedCharArray() colors.SetNumberOfComponents(3) colors.SetName("Colors") cnt = 0 noderange = 100 mod = 1 edges = nodes[0].getedges() points = vtk.vtkPoints() lines = vtk.vtkCellArray() nodecnt = 0 while cnt < len(nodes): node = nodes[cnt] cnt += 1 edges = node.getedges() for edge in edges: x0,y0,z0 = edge[0] x1,y1,z1 = edge[1] points.InsertNextPoint(edge[0]) points.InsertNextPoint(edge[1]) line = vtk.vtkLine() line.GetPointIds().SetId(0,nodecnt) line.GetPointIds().SetId(1,nodecnt+1) lines.InsertNextCell(line) nodecnt += 2 colors.InsertNextTupleValue(color) if cnt % mod == 0: print "noderange", noderange, "cnt", cnt, "mod",mod # Create a polydata to store everything in linesPolyData = vtk.vtkPolyData() # Add the points to the dataset linesPolyData.SetPoints(points) # Add the lines to the dataset linesPolyData.SetLines(lines) linesPolyData.GetCellData().SetScalars(colors) mapper = vtk.vtkPolyDataMapper() mapper.SetInput(linesPolyData) actor = vtk.vtkActor() actor.SetMapper(mapper) renderer.AddActor(actor) points = vtk.vtkPoints() lines = vtk.vtkCellArray() nodecnt = 0 renderWindow.Render() camera = renderer.GetActiveCamera() camera.Azimuth(0.1) print "done!"
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 InitializeSeeds(self): if (self.InteractionMode==0): self.SeedIds.Initialize() self.SeedPoints.Initialize() seedPoints = vtk.vtkPoints() self.SeedPoints.SetPoints(seedPoints) else: self.ExamineSpheres.Initialize() spherePoints = vtk.vtkPoints() self.ExamineSpheres.SetPoints(spherePoints) self.ExamineSpheres.GetPointData().Initialize() sphereRadii = vtk.vtkDoubleArray() self.ExamineSpheres.GetPointData().SetScalars(sphereRadii)
def onLandmarkMoved_NOT(self,state): """Perform the linear transform using the vtkLandmarkTransform class""" if state.transformed.GetTransformNodeID() != state.linearTransform.GetID(): state.transformed.SetAndObserveTransformNodeID(state.linearTransform.GetID()) self.linearMode = "Rigid" # try to use user selection, but fall back if not enough points are available landmarkTransform = vtk.vtkLandmarkTransform() if self.linearMode == 'Rigid': landmarkTransform.SetModeToRigidBody() if self.linearMode == 'Similarity': landmarkTransform.SetModeToSimilarity() if self.linearMode == 'Affine': landmarkTransform.SetModeToAffine() if state.fixedFiducials.GetNumberOfFiducials() < 3: landmarkTransform.SetModeToRigidBody() points = {} point = [0,]*3 for volumeNode in (state.fixed,state.moving): points[volumeNode] = vtk.vtkPoints() indices = range(state.fixedFiducials.GetNumberOfFiducials()) fiducialLists = (state.fixedFiducials,state.movingFiducials) volumeNodes = (state.fixed,state.moving) for fiducials,volumeNode in zip(fiducialLists,volumeNodes): for index in indices: fiducials.GetNthFiducialPosition(index,point) points[volumeNode].InsertNextPoint(point) landmarkTransform.SetSourceLandmarks(points[state.moving]) landmarkTransform.SetTargetLandmarks(points[state.fixed]) landmarkTransform.Update() t = state.linearTransform t.SetAndObserveMatrixTransformToParent(landmarkTransform.GetMatrix())
def make_cylinderActor (r, x0, x1, rgb, opacity): points = vtk.vtkPoints() lines = vtk.vtkCellArray() lines.InsertNextCell(2) # point 0 points.InsertNextPoint(x0[0], x0[1], x0[2]) lines.InsertCellPoint(0) # point 1 points.InsertNextPoint(x1[0], x1[1], x1[2]) lines.InsertCellPoint(1) cData = vtk.vtkPolyData() cData.SetPoints(points) cData.SetLines(lines) c = vtk.vtkTubeFilter() c.SetNumberOfSides(8) c.SetInput(cData) c.SetRadius(r) cMapper = vtk.vtkPolyDataMapper() cMapper.SetInput(c.GetOutput()) cActor = vtk.vtkActor() cActor.SetMapper(cMapper) cActor.GetProperty().SetColor(rgb[0], rgb[1], rgb[2]) cActor.GetProperty().SetOpacity(opacity) return cActor
def array2vtkPoints(num_array, vtk_points=None): """Converts a numpy array/Python list to a vtkPoints object. Unless a Python list/tuple or a non-contiguous array is given, no copy of the data is made. Thus the function is very efficient. Parameters ---------- - num_array : numpy array or Python list/tuple The input array must be 2D with `shape[1] == 3`. - vtk_points : `vtkPoints` (default: `None`) If an optional `vtkPoints` instance, is passed as an argument then a new array is not created and returned. The passed array is itself modified and returned. """ if vtk_points: points = vtk_points else: points = vtk.vtkPoints() arr = numpy.asarray(num_array) assert len(arr.shape) == 2, "Points array must be 2 dimensional." assert arr.shape[1] == 3, "Incorrect shape: shape[1] must be 3." vtk_array = array2vtk(arr) points.SetData(vtk_array) return points
def make_sphereActor (x, r, rgb, opacity): points = vtk.vtkPoints() points.InsertNextPoint(x[0], x[1], x[2]) diameter = vtk.vtkDoubleArray() diameter.SetNumberOfComponents(1) diameter.InsertNextTuple1(2.0*r) pData = vtk.vtkPolyData() pData.SetPoints(points) pData.GetPointData().SetScalars(diameter) pSource = vtk.vtkSphereSource() pSource.SetPhiResolution(16) pSource.SetThetaResolution(16) pGlyph = vtk.vtkGlyph3D() pGlyph.SetSource(pSource.GetOutput()) pGlyph.SetInput(pData) pGlyph.ScalingOn() pGlyph.SetScaleModeToScaleByScalar() pMapper = vtk.vtkPolyDataMapper() pMapper.ScalarVisibilityOff() pMapper.SetInput(pGlyph.GetOutput()) pActor = vtk.vtkActor() pActor.SetMapper(pMapper) pActor.GetProperty().SetColor(rgb[0], rgb[1], rgb[2]) pActor.GetProperty().SetOpacity(opacity) return pActor
def testTwoTrianglesCoplanar(): "Two triangles" # create set of points points = vtk.vtkPoints() points.SetNumberOfPoints(4) points.SetPoint(0, [0., 0., 0.]) points.SetPoint(1, [1., 0., 0.]) points.SetPoint(2, [0., 1., 0.]) points.SetPoint(3, [1., 1., 0.]) # create vtkPolyData object pdata = vtk.vtkPolyData() pdata.SetPoints(points) pdata.Allocate(2, 1) ptIds = vtk.vtkIdList() ptIds.SetNumberOfIds(3) ptIds.SetId(0, 0) ptIds.SetId(1, 1) ptIds.SetId(2, 2) pdata.InsertNextCell(vtk.VTK_POLYGON, ptIds) ptIds.SetId(0, 1) ptIds.SetId(1, 3) ptIds.SetId(2, 2) pdata.InsertNextCell(vtk.VTK_POLYGON, ptIds) for order in range(1, 6): lslm = PoissonSolver(pdata, max_edge_length=1000., order=order) print('order = ', order) print('g matrix: ', lslm.getGreenMatrix())
def createPolyData(faces, vtList, verts, tcoords): points = vtk.vtkPoints() points.SetDataTypeToDouble() points.SetNumberOfPoints(len(vtList)) tcoordArray = vtk.vtkDoubleArray() tcoordArray.SetName('tcoords') tcoordArray.SetNumberOfComponents(2) tcoordArray.SetNumberOfTuples(len(vtList)) for i, vt in enumerate(vtList): vi, ti = vt xyz = verts[vi] uv = tcoords[ti] points.SetPoint(i, xyz) tcoordArray.SetTuple2(i, uv[0], uv[1]) cells = vtk.vtkCellArray() for i, face in enumerate(faces): tri = vtk.vtkTriangle() tri.GetPointIds().SetId(0, face[0]) tri.GetPointIds().SetId(1, face[1]) tri.GetPointIds().SetId(2, face[2]) cells.InsertNextCell(tri) polyData = vtk.vtkPolyData() polyData.SetPoints(points) polyData.SetPolys(cells) polyData.GetPointData().SetTCoords(tcoordArray) return polyData
def _update_vtk_objects(self): """When n is changed the thus the number of coordinates this function is needed to update the vtk objects with the new number of points.""" # self._vtk_points.SetNumberOfPoints(len(self._points)) # for i, c in enumerate(self._points): # self._vtk_points.InsertPoint(i, c[0], c[1], c[2]) self._vtk_points = _vtk.vtkPoints() for coordinates in self._points: self._vtk_points.InsertNextPoint(coordinates[0], coordinates[1], coordinates[2]) self._vtk_polygons = _vtk.vtkCellArray() for polygon in self._polygons: vtk_polygon = _vtk.vtkPolygon() vtk_polygon.GetPointIds().SetNumberOfIds(3) for local_index, global_index in enumerate(polygon): vtk_polygon.GetPointIds().SetId(local_index, global_index) self._vtk_polygons.InsertNextCell(vtk_polygon) self._vtk_poly_data.SetPoints(self._vtk_points) self._vtk_poly_data.SetPolys(self._vtk_polygons) self._vtk_scalars = _vtk.vtkFloatArray() self._vtk_scalars.SetNumberOfValues(self._vtk_poly_data.GetPoints().GetNumberOfPoints()) for i in range(self._vtk_scalars.GetNumberOfTuples()): self._vtk_scalars.SetValue(i, 0.) self._vtk_poly_data.GetPointData().SetScalars(self._vtk_scalars) self._vtk_poly_data.Modified()
def testSingleTriangle(): "Single triangle" h = 0.1 # create set of points points = vtk.vtkPoints() points.SetNumberOfPoints(3) points.SetPoint(0, [1., -1.*h/3., -1.*h/3.]) points.SetPoint(1, [1., 2.*h/3., -1.*h/3.]) points.SetPoint(2, [1., -1.*h/3., 2.*h/3.]) # create vtkPolyData object pdata = vtk.vtkPolyData() pdata.SetPoints(points) ptIds = vtk.vtkIdList() ptIds.SetNumberOfIds(3) ptIds.SetId(0, 0) ptIds.SetId(1, 1) ptIds.SetId(2, 2) pdata.Allocate(1, 1) pdata.InsertNextCell(vtk.VTK_POLYGON, ptIds) for order in range(1, 6): lslm = PoissonSolver(pdata, max_edge_length=1000.) print('order = ', order) print('g matrix: ', lslm.getGreenMatrix())
def MakeHexagonalPrism(): ''' 3D: hexagonal prism: a wedge with an hexagonal base. Be careful, the base face ordering is different from wedge. ''' numberOfVertices = 12 points = vtk.vtkPoints() points.InsertNextPoint(0.0, 0.0, 1.0) points.InsertNextPoint(1.0, 0.0, 1.0) points.InsertNextPoint(1.5, 0.5, 1.0) points.InsertNextPoint(1.0, 1.0, 1.0) points.InsertNextPoint(0.0, 1.0, 1.0) points.InsertNextPoint(-0.5, 0.5, 1.0) points.InsertNextPoint(0.0, 0.0, 0.0) points.InsertNextPoint(1.0, 0.0, 0.0) points.InsertNextPoint(1.5, 0.5, 0.0) points.InsertNextPoint(1.0, 1.0, 0.0) points.InsertNextPoint(0.0, 1.0, 0.0) points.InsertNextPoint(-0.5, 0.5, 0.0) hexagonalPrism = vtk.vtkHexagonalPrism() for i in range(0, numberOfVertices): hexagonalPrism.GetPointIds().SetId(i, i) ug = vtk.vtkUnstructuredGrid() ug.InsertNextCell(hexagonalPrism.GetCellType(), hexagonalPrism.GetPointIds()) ug.SetPoints(points) return ug
def MakePentagonalPrism(): numberOfVertices = 10 # Create the points points = vtk.vtkPoints() points.InsertNextPoint(11, 10, 10) points.InsertNextPoint(13, 10, 10) points.InsertNextPoint(14, 12, 10) points.InsertNextPoint(12, 14, 10) points.InsertNextPoint(10, 12, 10) points.InsertNextPoint(11, 10, 14) points.InsertNextPoint(13, 10, 14) points.InsertNextPoint(14, 12, 14) points.InsertNextPoint(12, 14, 14) points.InsertNextPoint(10, 12, 14) # Pentagonal Prism pentagonalPrism = vtk.vtkPentagonalPrism() for i in range(0, numberOfVertices): pentagonalPrism.GetPointIds().SetId(i, i) # Add the points and hexahedron to an unstructured grid uGrid = vtk.vtkUnstructuredGrid() uGrid.SetPoints(points) uGrid.InsertNextCell(pentagonalPrism.GetCellType(), pentagonalPrism.GetPointIds()) return uGrid
def MakeVoxel(): ''' A voxel is a representation of a regular grid in 3-D space. ''' numberOfVertices = 8 points = vtk.vtkPoints() points.InsertNextPoint(0, 0, 0) points.InsertNextPoint(1, 0, 0) points.InsertNextPoint(0, 1, 0) points.InsertNextPoint(1, 1, 0) points.InsertNextPoint(0, 0, 1) points.InsertNextPoint(1, 0, 1) points.InsertNextPoint(0, 1, 1) points.InsertNextPoint(1, 1, 1) voxel = vtk.vtkVoxel() for i in range(0, numberOfVertices): voxel.GetPointIds().SetId(i, i) ug = vtk.vtkUnstructuredGrid() ug.SetPoints(points) ug.InsertNextCell(voxel.GetCellType(), voxel.GetPointIds()) return ug
def make_pData_periodic (np, x, a, lattice): pos = vtk.vtkPoints() diameter = vtk.vtkDoubleArray() diameter.SetNumberOfComponents(1) # primary cell for i in range(np): pos.InsertNextPoint(x[i*3], x[i*3+1], x[i*3+2]) if a != []: diameter.InsertNextTuple1(2.0*a[i]) else: diameter.InsertNextTuple1(2.0) # image cells for ix in range(-1,2): for iy in range(-1,2): for iz in range(-1,2): if ix == 0 and iy == 0 and iz == 0: continue for i in range(np): pos.InsertNextPoint(x[i*3 ]+float(ix)*lattice[0], x[i*3+1]+float(iy)*lattice[1], x[i*3+2]+float(iz)*lattice[2]) if a != []: diameter.InsertNextTuple1(2.0*a[i]) else: diameter.InsertNextTuple1(2.0) # first make pData containing particle coordinates pData = vtk.vtkPolyData() pData.SetPoints(pos) pData.GetPointData().SetScalars(diameter) return pData
def MakePyramid(): ''' Make a regular square pyramid. ''' numberOfVertices = 5 points = vtk.vtkPoints() p = [ [1.0, 1.0, 0.0], [-1.0, 1.0, 0.0], [-1.0, -1.0, 0.0], [1.0, -1.0, 0.0], [0.0, 0.0, 1.0] ] for pt in p: points.InsertNextPoint(pt) pyramid = vtk.vtkPyramid() for i in range(0, numberOfVertices): pyramid.GetPointIds().SetId(i, i) ug = vtk.vtkUnstructuredGrid() ug.SetPoints(points) ug.InsertNextCell(pyramid.GetCellType(), pyramid.GetPointIds()) return ug
def copyFirstNLines(self, sourcePolyData, lineCount): """make a polydata with only the first N polylines""" polyData = vtk.vtkPolyData() points = vtk.vtkPoints() polyData.SetPoints(points) lines = vtk.vtkCellArray() polyData.SetLines(lines) sourcePoints = sourcePolyData.GetPoints() sourceLines = sourcePolyData.GetLines() sourceIdList = vtk.vtkIdList() sourceLines.InitTraversal() while sourceLines.GetNextCell(sourceIdList): pointCount = sourceIdList.GetNumberOfIds() idList = vtk.vtkIdList() for idIndex in range(pointCount): sourceId = sourceIdList.GetId(idIndex) point = sourcePoints.GetPoint(sourceId) id = points.InsertNextPoint(point) idList.InsertNextId(id) lines.InsertNextCell(idList) if lines.GetNumberOfCells() > lineCount: break return polyData
def MakeWedge(): ''' A wedge consists of two triangular ends and three rectangular faces. ''' numberOfVertices = 6 points = vtk.vtkPoints() points.InsertNextPoint(0, 1, 0) points.InsertNextPoint(0, 0, 0) points.InsertNextPoint(0, .5, .5) points.InsertNextPoint(1, 1, 0) points.InsertNextPoint(1, 0.0, 0.0) points.InsertNextPoint(1, .5, .5) wedge = vtk.vtkWedge() for i in range(0, numberOfVertices): wedge.GetPointIds().SetId(i, i) ug = vtk.vtkUnstructuredGrid() ug.SetPoints(points) ug.InsertNextCell(wedge.GetCellType(), wedge.GetPointIds()) return ug
def _render_blurry_particles(self, particles_dataset): particles_per_species = dict( (k, vtk.vtkPoints()) for k in self._species_idmap.iterkeys()) scaling = self.settings.scaling position_idx = particles_dataset.dtype.names.index('position') species_id_idx = particles_dataset.dtype.names.index('species_id') for p in particles_dataset: pos = p[position_idx] display_species_id = self._species_idmap.get(p[species_id_idx]) if display_species_id is None: continue particles_per_species[display_species_id].InsertNextPoint( pos * scaling / self._world_size) nx = ny = nz = self.settings.fluorimetry_axial_voxel_number for display_species_id, points in particles_per_species.iteritems(): poly_data = vtk.vtkPolyData() poly_data.SetPoints(points) poly_data.ComputeBounds() pattr = self._pattrs[display_species_id] # Calc standard deviation of gauss distribution function wave_length = pattr['fluorimetry_wave_length'] sigma = scaling * 0.5 * wave_length / self._world_size # Create guassian splatter gs = vtk.vtkGaussianSplatter() gs.SetInput(poly_data) gs.SetSampleDimensions(nx, ny, nz) gs.SetRadius(sigma) gs.SetExponentFactor(-.5) gs.ScalarWarpingOff() gs.SetModelBounds([-sigma, scaling + sigma] * 3) gs.SetAccumulationModeToMax() # Create filter for volume rendering filter = vtk.vtkImageShiftScale() # Scales to unsigned char filter.SetScale(255. * pattr['fluorimetry_brightness']) filter.ClampOverflowOn() filter.SetOutputScalarTypeToUnsignedChar() filter.SetInputConnection(gs.GetOutputPort()) mapper = vtk.vtkFixedPointVolumeRayCastMapper() mapper.SetInputConnection(filter.GetOutputPort()) volume = vtk.vtkVolume() property = volume.GetProperty() # vtk.vtkVolumeProperty() color = pattr['fluorimetry_luminescence_color'] color_tfunc = vtk.vtkColorTransferFunction() color_tfunc.AddRGBPoint(0, color[0], color[1], color[2]) property.SetColor(color_tfunc) opacity_tfunc = vtk.vtkPiecewiseFunction() opacity_tfunc.AddPoint(0, 0.0) opacity_tfunc.AddPoint(255., 1.0) property.SetScalarOpacity(opacity_tfunc) property.SetInterpolationTypeToLinear() if self.settings.fluorimetry_shadow_display: property.ShadeOn() else: property.ShadeOff() volume.SetMapper(mapper) self.renderer.AddVolume(volume)
def run(self, baseMeshNode, baseLMNode, semiLMNode, meshDirectory, lmDirectory, ouputDirectory, outputExtension, scaleProjection): SLLogic = CreateSemiLMPatches.CreateSemiLMPatchesLogic() targetPoints = vtk.vtkPoints() point = [0, 0, 0] # estimate a sample size usingn semi-landmark spacing sampleArray = np.zeros(shape=(25, 3)) for i in range(25): semiLMNode.GetMarkupPoint(0, i, point) sampleArray[i, :] = point sampleDistances = self.distanceMatrix(sampleArray) minimumMeshSpacing = sampleDistances[sampleDistances.nonzero()].min( axis=0) rayLength = minimumMeshSpacing * (scaleProjection) for i in range(baseLMNode.GetNumberOfFiducials()): baseLMNode.GetMarkupPoint(0, i, point) targetPoints.InsertNextPoint(point) for meshFileName in os.listdir(meshDirectory): if (not meshFileName.startswith(".")): print(meshFileName) lmFileList = os.listdir(lmDirectory) meshFilePath = os.path.join(meshDirectory, meshFileName) regex = re.compile(r'\d+') subjectID = [int(x) for x in regex.findall(meshFileName)][0] for lmFileName in lmFileList: if str(subjectID) in lmFileName: # if mesh and lm file with same subject id exist, load into scene currentMeshNode = slicer.util.loadModel(meshFilePath) lmFilePath = os.path.join(lmDirectory, lmFileName) success, currentLMNode = slicer.util.loadMarkupsFiducialList( lmFilePath) # set up transform between base lms and current lms sourcePoints = vtk.vtkPoints() for i in range(currentLMNode.GetNumberOfMarkups()): currentLMNode.GetMarkupPoint(0, i, point) sourcePoints.InsertNextPoint(point) transform = vtk.vtkThinPlateSplineTransform() transform.SetSourceLandmarks(sourcePoints) transform.SetTargetLandmarks(targetPoints) transform.SetBasisToR() # for 3D transform transformNode = slicer.mrmlScene.AddNewNodeByClass( "vtkMRMLTransformNode", "TPS") transformNode.SetAndObserveTransformToParent(transform) # apply transform to the current surface mesh currentMeshNode.SetAndObserveTransformNodeID( transformNode.GetID()) slicer.vtkSlicerTransformLogic().hardenTransform( currentMeshNode) # project semi-landmarks resampledLandmarkNode = slicer.mrmlScene.AddNewNodeByClass( 'vtkMRMLMarkupsFiducialNode', meshFileName + '_SL_warped') success = SLLogic.projectPoints( baseMeshNode, currentMeshNode, semiLMNode, resampledLandmarkNode, rayLength) transformNode.Inverse() resampledLandmarkNode.SetAndObserveTransformNodeID( transformNode.GetID()) slicer.vtkSlicerTransformLogic().hardenTransform( resampledLandmarkNode) # transfer point data for index in range( semiLMNode.GetNumberOfControlPoints()): fiducialLabel = semiLMNode.GetNthControlPointLabel( index) fiducialDescription = semiLMNode.GetNthControlPointDescription( index) resampledLandmarkNode.SetNthControlPointLabel( index, fiducialLabel) resampledLandmarkNode.SetNthControlPointDescription( index, fiducialDescription) # save output file outputFileName = meshFileName + '_SL_warped' + outputExtension outputFilePath = os.path.join(ouputDirectory, outputFileName) slicer.util.saveNode(resampledLandmarkNode, outputFilePath) # clean up slicer.mrmlScene.RemoveNode(resampledLandmarkNode) slicer.mrmlScene.RemoveNode(currentLMNode) slicer.mrmlScene.RemoveNode(currentMeshNode) slicer.mrmlScene.RemoveNode(transformNode)
def readpoints(filename): points = vtk.vtkPoints() file = open(filename, "r") xdim = int(raw_input("Please Enter the X-Dimension: ")) ydim = int(raw_input("Please Enter the Y-Dimension: ")) zdim = int(raw_input("Please Enter the Z-Dimension: ")) m = 0 a = 0 while file: line = file.readline() if line == "": break line = str.rstrip(line) cols = line.split(' ') if len(cols) < 3: if line.find('-') == 0: print "Treating as options: ", line processOption(line) else: print "Omitting line: ", line continue x = cols[1] y = cols[2] z = cols[3] p = float(z) if m == 0: zmin = p if m >= 1: zmax = p p = (round(zmin) >= (zdim - 2)) and (round(zmax) <= 1) if p == 1: d = m - 1 a = a + 1 if a == 1: t = d zmin = zmax points.InsertNextPoint(float(x), float(y), float(z)) #print m m = m + 1 #Define Scalar and vectors scalars = vtk.vtkFloatArray() scalars.SetNumberOfTuples(m) vector = vtk.vtkFloatArray() vector.SetNumberOfComponents(3) vector.SetNumberOfTuples(m) pdata = vtk.vtkPolyData() pline = vtk.vtkCellArray() pline.InsertNextCell(t) for i in range(0, t): pline.InsertCellPoint(i) pline.InsertNextCell(d - t - 1) for i in range(t + 1, d): pline.InsertCellPoint(i) pline.InsertNextCell(m - d - 1) for i in range(d + 1, m): pline.InsertCellPoint(i) pdata.SetPoints(points) pdata.SetLines(pline) pdata.GetPointData().SetVectors(vector) profileTubes = vtk.vtkTubeFilter() profileTubes.SetNumberOfSides(4) profileTubes.SetInput(pdata) profileTubes.SetRadius(0.75) slineGrid = vtk.vtkStructuredGrid() #slineGrid.Allocate(10,10) #slineGrid.InsertNextCell(12,Idlist) slineGrid.GetPointData().SetScalars(scalars) slineGrid.GetPointData().SetVectors(vector) slineGrid.GetPointData().AddArray slineGrid.SetPoints(points) map = vtk.vtkDataSetMapper() map.SetInputConnection(profileTubes.GetOutputPort()) triangulation = vtk.vtkActor() triangulation.SetMapper(map) triangulation.GetProperty().SetColor(1, 0, 0) ren.AddActor(triangulation) ren.SetBackground(1, 1, 1)
def surf_fill_vtk(vertices, polys, mat, shape): """ :param vertices: :param polys: :param mat: :param shape: :return: """ import vtk from vtk.util import numpy_support voxverts = nibabel.affines.apply_affine(numpy.linalg.inv(mat), vertices) points = vtk.vtkPoints() points.SetNumberOfPoints(len(voxverts)) for i, pt in enumerate(voxverts): points.InsertPoint(i, pt) tris = vtk.vtkCellArray() for vert in polys: tris.InsertNextCell(len(vert)) for v in vert: tris.InsertCellPoint(v) pd = vtk.vtkPolyData() pd.SetPoints(points) pd.SetPolys(tris) del points, tris whiteimg = vtk.vtkImageData() whiteimg.SetDimensions(shape) if vtk.VTK_MAJOR_VERSION <= 5: whiteimg.SetScalarType(vtk.VTK_UNSIGNED_CHAR) else: info = vtk.vtkInformation() whiteimg.SetPointDataActiveScalarInfo(info, vtk.VTK_UNSIGNED_CHAR, 1) ones = numpy.ones(numpy.prod(shape), dtype=numpy.uint8) whiteimg.GetPointData().SetScalars( numpy_support.numpy_to_vtk(ones)) pdtis = vtk.vtkPolyDataToImageStencil() if vtk.VTK_MAJOR_VERSION <= 5: pdtis.SetInput(pd) else: pdtis.SetInputData(pd) pdtis.SetOutputWholeExtent(whiteimg.GetExtent()) pdtis.Update() imgstenc = vtk.vtkImageStencil() if vtk.VTK_MAJOR_VERSION <= 5: imgstenc.SetInput(whiteimg) imgstenc.SetStencil(pdtis.GetOutput()) else: imgstenc.SetInputData(whiteimg) imgstenc.SetStencilConnection(pdtis.GetOutputPort()) imgstenc.SetBackgroundValue(0) imgstenc.Update() data = numpy_support.vtk_to_numpy( imgstenc.GetOutput().GetPointData().GetScalars()).reshape( shape).transpose(2, 1, 0) del pd, voxverts, whiteimg, pdtis, imgstenc return data
def main(): colors = vtk.vtkNamedColors() aren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(aren) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) # Create single splat point pts = vtk.vtkPoints() verts = vtk.vtkCellArray() norms = vtk.vtkDoubleArray() scalars = vtk.vtkDoubleArray() x = [0.0] * 3 pts.InsertNextPoint(x) norms.SetNumberOfTuples(1) norms.SetNumberOfComponents(3) n = [0] * 3 n[0] = 0.707 n[1] = 0.707 n[2] = 0.0 norms.InsertTuple(0, n) scalars.SetNumberOfTuples(1) scalars.SetNumberOfComponents(1) scalars.InsertTuple1(0, 1.0) verts.InsertNextCell(1) verts.InsertCellPoint(0) pData = vtk.vtkPolyData() pData.SetPoints(pts) pData.SetVerts(verts) pData.GetPointData().SetNormals(norms) pData.GetPointData().SetScalars(scalars) # Splat point and generate isosurface. splat = vtk.vtkGaussianSplatter() splat.SetInputData(pData) splat.SetModelBounds(-1.0, 1.0, -1.0, 1.0, -1.0, 1.0) splat.SetSampleDimensions(75, 75, 75) splat.SetRadius(0.5) splat.SetEccentricity(5.0) splat.SetExponentFactor(-3.25) contour = vtk.vtkContourFilter() contour.SetInputConnection(splat.GetOutputPort()) contour.SetValue(0, 0.9) splatMapper = vtk.vtkPolyDataMapper() splatMapper.SetInputConnection(contour.GetOutputPort()) splatActor = vtk.vtkActor() splatActor.SetMapper(splatMapper) # Create outline. outline = vtk.vtkOutlineFilter() outline.SetInputConnection(splat.GetOutputPort()) outlineMapper = vtk.vtkPolyDataMapper() outlineMapper.SetInputConnection(outline.GetOutputPort()) outlineActor = vtk.vtkActor() outlineActor.SetMapper(outlineMapper) outlineActor.GetProperty().SetColor(colors.GetColor3d('Brown')) # Create cone to indicate direction. cone = vtk.vtkConeSource() cone.SetResolution(24) coneMapper = vtk.vtkPolyDataMapper() coneMapper.SetInputConnection(cone.GetOutputPort()) coneActor = vtk.vtkActor() coneActor.SetMapper(coneMapper) coneActor.SetScale(0.75, 0.75, 0.75) coneActor.RotateZ(45.0) coneActor.AddPosition(0.50, 0.50, 0.0) coneActor.GetProperty().SetColor(colors.GetColor3d('DeepPink')) # # Rendering stuff. # aren.SetBackground(colors.GetColor3d('Beige')) aren.AddActor(splatActor) aren.AddActor(outlineActor) aren.AddActor(coneActor) renWin.SetSize(640, 640) renWin.SetWindowName('SingleSplat') renWin.Render() # Interact with the data. iren.Start()
def main(): angle, step, radius, uncapped, show_line = get_program_parameters() angle = math.radians(abs(angle)) step = math.radians(abs(step)) radius = abs(radius) # With default settings set this to 45 and you get a bowl with a flat bottom. start = math.radians(90) pts = get_line(angle, step, radius, uncapped, start) # Setup points and lines points = vtk.vtkPoints() lines = vtk.vtkCellArray() for pt in pts: pt_id = points.InsertNextPoint(pt) if pt_id < len(pts) - 1: line = vtk.vtkLine() line.GetPointIds().SetId(0, pt_id) line.GetPointIds().SetId(1, pt_id + 1) lines.InsertNextCell(line) polydata = vtk.vtkPolyData() polydata.SetPoints(points) polydata.SetLines(lines) # Extrude the profile to make the capped sphere extrude = vtk.vtkRotationalExtrusionFilter() extrude.SetInputData(polydata) extrude.SetResolution(60) # Visualize colors = vtk.vtkNamedColors() # To see the line lineMapper = vtk.vtkPolyDataMapper() lineMapper.SetInputData(polydata) lineActor = vtk.vtkActor() lineActor.SetMapper(lineMapper) lineActor.GetProperty().SetLineWidth(4) lineActor.GetProperty().SetColor(colors.GetColor3d("Red")) # To see the surface surfaceMapper = vtk.vtkPolyDataMapper() surfaceMapper.SetInputConnection(extrude.GetOutputPort()) surfaceActor = vtk.vtkActor() surfaceActor.SetMapper(surfaceMapper) surfaceActor.GetProperty().SetColor(colors.GetColor3d('Khaki')) ren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) ren.AddActor(surfaceActor) if show_line: ren.AddActor(lineActor) ren.SetBackground(colors.GetColor3d('LightSlateGray')) ren.ResetCamera() ren.GetActiveCamera().Azimuth(0) ren.GetActiveCamera().Elevation(60) ren.ResetCameraClippingRange() renWin.SetSize(600, 600) renWin.Render() renWin.SetWindowName('CappedSphere') iren.Start()
def decimate(points, faces, reduction=0.75, smooth_steps=25, scalars=[], save_vtk=False, output_vtk=''): """ Decimate vtk triangular mesh with vtk.vtkDecimatePro. Parameters ---------- points : list of lists of floats each element is a list of 3-D coordinates of a vertex on a surface mesh faces : list of lists of integers each element is list of 3 indices of vertices that form a face on a surface mesh reduction : float fraction of mesh faces to remove smooth_steps : integer number of smoothing steps scalars : list of integers or floats optional scalars for output VTK file save_vtk : bool output decimated vtk file? output_vtk : string output decimated vtk file name Returns ------- points : list of lists of floats decimated points faces : list of lists of integers decimated faces scalars : list of integers or floats scalars for output VTK file output_vtk : string output decimated vtk file Examples -------- >>> # Example: Twins-2-1 left postcentral pial surface, 0.75 decimation: >>> from mindboggle.guts.mesh import decimate >>> from mindboggle.mio.vtks import read_vtk >>> from mindboggle.mio.fetch_data import prep_tests >>> urls, fetch_data = prep_tests() >>> input_vtk = fetch_data(urls['left_freesurfer_labels']) >>> points, f1, f2, faces, scalars, f3, f4, f5 = read_vtk(input_vtk) >>> reduction = 0.5 >>> smooth_steps = 25 >>> save_vtk = True >>> output_vtk = '' >>> points2, faces2, scalars, output_vtk = decimate(points, faces, ... reduction, smooth_steps, scalars, save_vtk, output_vtk) >>> (len(points), len(points2)) (145069, 72535) >>> (len(faces), len(faces2)) (290134, 145066) View decimated surface (skip test): >>> from mindboggle.mio.plots import plot_surfaces >>> plot_surfaces('decimated.vtk') # doctest: +SKIP """ import os import vtk #------------------------------------------------------------------------- # vtk points: #------------------------------------------------------------------------- vtk_points = vtk.vtkPoints() [vtk_points.InsertPoint(i, x[0], x[1], x[2]) for i, x in enumerate(points)] #------------------------------------------------------------------------- # vtk faces: #------------------------------------------------------------------------- vtk_faces = vtk.vtkCellArray() for face in faces: vtk_face = vtk.vtkPolygon() vtk_face.GetPointIds().SetNumberOfIds(3) vtk_face.GetPointIds().SetId(0, face[0]) vtk_face.GetPointIds().SetId(1, face[1]) vtk_face.GetPointIds().SetId(2, face[2]) vtk_faces.InsertNextCell(vtk_face) #------------------------------------------------------------------------- # vtk scalars: #------------------------------------------------------------------------- if scalars: vtk_scalars = vtk.vtkFloatArray() vtk_scalars.SetName("scalars") for scalar in scalars: vtk_scalars.InsertNextValue(scalar) #------------------------------------------------------------------------- # vtkPolyData: #------------------------------------------------------------------------- polydata = vtk.vtkPolyData() polydata.SetPoints(vtk_points) polydata.SetPolys(vtk_faces) if scalars: polydata.GetPointData().SetScalars(vtk_scalars) #------------------------------------------------------------------------- # Decimate: #------------------------------------------------------------------------- # We want to preserve topology (not let any cracks form). # This may limit the total reduction possible. decimate = vtk.vtkDecimatePro() # Migrate to VTK6: # http://www.vtk.org/Wiki/VTK/VTK_6_Migration/Replacement_of_SetInput # Old: decimate.SetInput(polydata) decimate.SetInputData(polydata) decimate.SetTargetReduction(reduction) decimate.PreserveTopologyOn() #------------------------------------------------------------------------- # Smooth: #------------------------------------------------------------------------- if save_vtk: if not output_vtk: output_vtk = os.path.join(os.getcwd(), 'decimated.vtk') exporter = vtk.vtkPolyDataWriter() else: output_vtk = None if smooth_steps > 0: smoother = vtk.vtkSmoothPolyDataFilter() # Migrate to VTK6: # http://www.vtk.org/Wiki/VTK/VTK_6_Migration/Replacement_of_SetInput # Old: smoother.SetInput(decimate.GetOutput()) smoother.SetInputConnection(decimate.GetOutputPort()) smoother.SetNumberOfIterations(smooth_steps) smoother.Update() out = smoother.GetOutput() # Migrate to VTK6: # http://www.vtk.org/Wiki/VTK/VTK_6_Migration/Replacement_of_SetInput # Old: exporter.SetInput(smoother.GetOutput()) exporter.SetInputConnection(smoother.GetOutputPort()) else: decimate.Update() out = decimate.GetOutput() if save_vtk: # Migrate to VTK6: # http://www.vtk.org/Wiki/VTK/VTK_6_Migration/Replacement_of_SetInput # http://stackoverflow.com/questions/29020740/ # what-is-the-difference-in-setinputconnection-and-setinput # Old: exporter.SetInput(decimate.GetOutput()) exporter.SetInputConnection(decimate.GetOutputPort()) #------------------------------------------------------------------------- # Export output: #------------------------------------------------------------------------- if save_vtk: exporter.SetFileName(output_vtk) exporter.Write() if not os.path.exists(output_vtk): raise IOError(output_vtk + " not found") #------------------------------------------------------------------------- # Extract decimated points, faces, and scalars: #------------------------------------------------------------------------- points = [ list(out.GetPoint(point_id)) for point_id in range(out.GetNumberOfPoints()) ] if out.GetNumberOfPolys() > 0: polys = out.GetPolys() pt_data = out.GetPointData() faces = [[ int(polys.GetData().GetValue(j)) for j in range(i * 4 + 1, i * 4 + 4) ] for i in range(polys.GetNumberOfCells())] if scalars: scalars = [ pt_data.GetScalars().GetValue(i) for i in range(len(points)) ] else: faces = [] scalars = [] return points, faces, scalars, output_vtk
def writeVTK(self, fileName, models=None): """Function to write a VTU file from a TreeMesh and model.""" import vtk from vtk import vtkXMLUnstructuredGridWriter as Writer, VTK_VERSION from vtk.util.numpy_support import numpy_to_vtk, numpy_to_vtkIdTypeArray # Make the data parts for the vtu object # Points #mesh.number() if (type(mesh) is TreeMesh): ptshMat = mesh.gridhN ptsMat = np.vstack((mesh.gridN, mesh.gridhN)) else: ptsMat = mesh._gridN + mesh.x0 vtkPts = vtk.vtkPoints() vtkPts.SetData(numpy_to_vtk(ptsMat, deep=True)) # Cells cellConn = np.array([c.nodes for c in mesh], dtype=np.int64) cellsMat = np.concatenate((np.ones( (cellConn.shape[0], 1), dtype=np.int64) * cellConn.shape[1], cellConn), axis=1).ravel() cellsArr = vtk.vtkCellArray() cellsArr.SetNumberOfCells(cellConn.shape[0]) cellsArr.SetCells(cellConn.shape[0], numpy_to_vtkIdTypeArray(cellsMat, deep=True)) # Make the object vtuObj = vtk.vtkUnstructuredGrid() vtuObj.SetPoints(vtkPts) vtuObj.SetCells(vtk.VTK_VOXEL, cellsArr) # Add the level of refinement as a cell array cellSides = np.array([ np.array(vtuObj.GetCell(i).GetBounds()).reshape( (3, 2)).dot(np.array([-1, 1])) for i in np.arange(vtuObj.GetNumberOfCells()) ]) uniqueLevel, indLevel = np.unique(np.prod(cellSides, axis=1), return_inverse=True) refineLevelArr = numpy_to_vtk(indLevel.max() - indLevel, deep=1) refineLevelArr.SetName('octreeLevel') vtuObj.GetCellData().AddArray(refineLevelArr) # Assign the model('s) to the object if models is not None: for item in six.iteritems(models): # Convert numpy array vtkDoubleArr = numpy_to_vtk(item[1], deep=1) vtkDoubleArr.SetName(item[0]) vtuObj.GetCellData().AddArray(vtkDoubleArr) # Make the writer vtuWriteFilter = Writer() if float(VTK_VERSION.split('.')[0]) >= 6: vtuWriteFilter.SetInputData(vtuObj) else: vtuWriteFilter.SetInput(vtuObj) vtuWriteFilter.SetFileName(fileName) # Write the file vtuWriteFilter.Update()
def Cull(in0, out0): """ Create BTPolygon from points in input, Compute Original Area Error = 0 while Error < MaxError foreach vertex in input Create Polygon from input, minus this vertex Compute area subtract area from original area endfor find minimum error vertex, remove it Error = minimum error """ """ Do an initial point count reduction based on curvature through vertices of the polygons """ in2 = vtk.vtkPolyData() ReducePolyData2D(in0, in2, 1) print("Number of points after reduction: %d\n" % in2.GetNumberOfPoints()) originalArea = PolyDataArea(in2) print("Original area: %f" % (originalArea)) # # SWAG numbers -- accept # area change of 0.5%, # regard 0.005% as the same as zero maxError = originalArea * 0.005 errEpsilon = maxError * 0.001 curPoints = vtk.vtkPoints() curPoints.DeepCopy(in2.GetPoints()) PointCount = curPoints.GetNumberOfPoints() ids = vtk.vtkIdList() ids.SetNumberOfIds(PointCount - 1) minErrorPointID = -1 while (True): minError = 10000000.0 for i in range(PointCount): IdsMinusThisPoint(ids, PointCount, i) normal = (0.0, 0.0, 0.0) curArea = vtk.vtkPolygon.ComputeArea(curPoints, PointCount - 1, ids, normal) thisError = math.fabs(originalArea - curArea) if (thisError < minError): minError = thisError minErrorPointID = i if (thisError < errEpsilon): break # if we have a new winner for least important point if (minError <= maxError): newPoints = vtk.vtkPoints() for i in range(PointCount): if (i == minErrorPointID): continue point = curPoints.GetPoint(i) newPoints.InsertNextPoint(point) curPoints.Delete() curPoints = newPoints PointCount = PointCount - 1 else: break out0 = ConvertPointSequenceToPolyData(curPoints, 1) curPoints.Delete() in2.Delete()
colors.InsertComponent(0,1,99) colors.InsertComponent(0,2,71) colors.InsertComponent(1,0,125) colors.InsertComponent(1,1,255) colors.InsertComponent(1,2,0) colors.InsertComponent(2,0,226) colors.InsertComponent(2,1,207) colors.InsertComponent(2,2,87) sizes = vtk.vtkUnsignedCharArray() sizes.SetName("Sizes") sizes.SetNumberOfComponents(1) sizes.SetNumberOfTuples(3) sizes.SetValue(0,1) sizes.SetValue(1,2) sizes.SetValue(2,3) polyVertexPoints = vtk.vtkPoints() polyVertexPoints.SetNumberOfPoints(3) polyVertexPoints.InsertPoint(0,0.0,0.0,0.0) polyVertexPoints.InsertPoint(1,2.5,0.0,0.0) polyVertexPoints.InsertPoint(2,5.0,0.0,0.0) aPolyVertex = vtk.vtkPolyVertex() aPolyVertex.GetPointIds().SetNumberOfIds(3) aPolyVertex.GetPointIds().SetId(0,0) aPolyVertex.GetPointIds().SetId(1,1) aPolyVertex.GetPointIds().SetId(2,2) aPolyVertexGrid = vtk.vtkUnstructuredGrid() aPolyVertexGrid.Allocate(1,1) aPolyVertexGrid.InsertNextCell(aPolyVertex.GetCellType(),aPolyVertex.GetPointIds()) aPolyVertexGrid.SetPoints(polyVertexPoints) aPolyVertexGrid.GetPointData().SetScalars(sizes) aPolyVertexGrid.GetPointData().AddArray(colors)
https://vtk.org/doc/nightly/html/classvtkSelectPolyData.html """ import vtk import random renderer = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(renderer) renWin.SetSize(1500, 1500) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) iren.SetInteractorStyle(vtk.vtkInteractorStyleTrackballCamera()) #Make Control Point landmark = vtk.vtkPoints() landmark.InsertNextPoint( [random.randrange(0, 10) / 10, random.randrange(0, 10) / 10, 0.0]) landmark.InsertNextPoint( [random.randrange(0, 10) / 10, random.randrange(0, 10) / 10, 0.0]) landmark.InsertNextPoint( [random.randrange(0, 10) / 10, random.randrange(0, 10) / 10, 0.0]) # landmark.InsertNextPoint([random.randrange(0, 10)/10, random.randrange(0, 10)/10, 0.0]) # landmark.InsertNextPoint([random.randrange(0, 10)/10, random.randrange(0, 10)/10, 0.0]) # landmark.InsertNextPoint([random.randrange(0, 10)/10, random.randrange(0, 10)/10, 0.0]) landmarkActor = vtk.vtkActor() pickedPoint = -1
math.cos(delta)*math.cos(gam)*(2*3.14159265)/lam ) vectorarr = vtk.vtkDoubleArray() vectorarr.SetNumberOfComponents(3) vectorarr.SetNumberOfTuples(3) vectorarr.SetComponent(0, 0, Qlabcenter1) vectorarr.SetComponent(0, 1, Qlabcenter2) vectorarr.SetComponent(0, 2, Qlabcenter3) vectorarr.SetComponent(1, 0, ki[0]) vectorarr.SetComponent(1, 1, ki[1]) vectorarr.SetComponent(1, 2, ki[2]) vectorarr.SetComponent(2, 0, kf[0]) vectorarr.SetComponent(2, 1, kf[1]) vectorarr.SetComponent(2, 2, kf[2]) vectorpoints = vtk.vtkPoints() vectorpoints.SetDataTypeToDouble() vectorpoints.SetNumberOfPoints(3) vectorpoints.SetPoint(0, (0.0, 0.0, 0.0)) vectorpoints.SetPoint(1, (0.0, 0.0, 0.0)) vectorpoints.SetPoint(2, (0.0, 0.0, 0.0)) vectorgrid = vtk.vtkUnstructuredGrid() vectorgrid.SetPoints(vectorpoints) vectorgrid.GetPointData().SetVectors(vectorarr) usgridwriter = vtk.vtkUnstructuredGridWriter() usgridwriter.SetFileName('Qvector.vtk') usgridwriter.SetFileTypeToASCII() usgridwriter.SetInput(vectorgrid) usgridwriter.Write()
def build_vtk(self): '''Build a vtkUnstructuredGrid instance corresponding to the mesh. This method creates a new vtkUnstructuredGrid object, set the nodes and the elements. :returns: the vtkUnstructuredGrid object. ''' print('building vtk stuff for FE_Mesh') vtk_mesh = vtk.vtkUnstructuredGrid() # take care of nodes nodes = vtk.vtkPoints() nodes.SetNumberOfPoints(self.get_number_of_nodes()); for i in range(self.get_number_of_nodes()): (x, y, z) = self._nodes[i]._x, self._nodes[i]._y, self._nodes[i]._z nodes.InsertPoint(i, x, y, z) # here i == self._nodes[i].give_rank() vtk_mesh.SetPoints(nodes) # take care of elements for i in range(self.get_number_of_elements()): el = self._elements[i] vtk_type = FE_Mesh.to_vtk_element_type(el._type) # allocate memory for this element type # vtk_mesh.Allocate(vtk_type, numpy.shape(el_list)[0]) if el._type in ['c2d3', 's3d3', 'c3d4', 'c3d6', 'c3d8', 'c3d13']: Ids = vtk.vtkIdList() for j in range(len(el._nodelist)): Ids.InsertNextId(el._nodelist[j].give_rank()) vtk_mesh.InsertNextCell(vtk_type, Ids) elif el._type.startswith('c3d10'): Ids = vtk.vtkIdList() Ids.InsertNextId(el._nodelist[0].give_rank()) Ids.InsertNextId(el._nodelist[2].give_rank()) Ids.InsertNextId(el._nodelist[1].give_rank()) Ids.InsertNextId(el._nodelist[9].give_rank()) Ids.InsertNextId(el._nodelist[5].give_rank()) Ids.InsertNextId(el._nodelist[4].give_rank()) Ids.InsertNextId(el._nodelist[3].give_rank()) Ids.InsertNextId(el._nodelist[6].give_rank()) Ids.InsertNextId(el._nodelist[8].give_rank()) Ids.InsertNextId(el._nodelist[7].give_rank()) vtk_mesh.InsertNextCell(vtk_type, Ids) elif el._type.startswith('c3d15'): Ids = vtk.vtkIdList() Ids.InsertNextId(el._nodelist[0].give_rank()) Ids.InsertNextId(el._nodelist[2].give_rank()) Ids.InsertNextId(el._nodelist[4].give_rank()) Ids.InsertNextId(el._nodelist[9].give_rank()) Ids.InsertNextId(el._nodelist[11].give_rank()) Ids.InsertNextId(el._nodelist[13].give_rank()) Ids.InsertNextId(el._nodelist[1].give_rank()) Ids.InsertNextId(el._nodelist[3].give_rank()) Ids.InsertNextId(el._nodelist[5].give_rank()) Ids.InsertNextId(el._nodelist[10].give_rank()) Ids.InsertNextId(el._nodelist[12].give_rank()) Ids.InsertNextId(el._nodelist[14].give_rank()) Ids.InsertNextId(el._nodelist[6].give_rank()) Ids.InsertNextId(el._nodelist[7].give_rank()) Ids.InsertNextId(el._nodelist[8].give_rank()) vtk_mesh.InsertNextCell(vtk_type, Ids) elif el._type.startswith('c3d20'): Ids = vtk.vtkIdList() Ids.InsertNextId(el._nodelist[0].give_rank()) Ids.InsertNextId(el._nodelist[6].give_rank()) Ids.InsertNextId(el._nodelist[4].give_rank()) Ids.InsertNextId(el._nodelist[2].give_rank()) Ids.InsertNextId(el._nodelist[12].give_rank()) Ids.InsertNextId(el._nodelist[18].give_rank()) Ids.InsertNextId(el._nodelist[16].give_rank()) Ids.InsertNextId(el._nodelist[14].give_rank()) Ids.InsertNextId(el._nodelist[7].give_rank()) Ids.InsertNextId(el._nodelist[5].give_rank()) Ids.InsertNextId(el._nodelist[3].give_rank()) Ids.InsertNextId(el._nodelist[1].give_rank()) Ids.InsertNextId(el._nodelist[19].give_rank()) Ids.InsertNextId(el._nodelist[17].give_rank()) Ids.InsertNextId(el._nodelist[15].give_rank()) Ids.InsertNextId(el._nodelist[13].give_rank()) Ids.InsertNextId(el._nodelist[8].give_rank()) Ids.InsertNextId(el._nodelist[11].give_rank()) Ids.InsertNextId(el._nodelist[10].give_rank()) Ids.InsertNextId(el._nodelist[9].give_rank()) vtk_mesh.InsertNextCell(vtk_type, Ids) elif el._type.startswith('c2d4') or el._type.startswith('s3d4'): Ids = vtk.vtkIdList() for j in range(len(el._nodelist)): Ids.InsertNextId(el._nodelist[j].give_rank()) vtk_mesh.InsertNextCell(vtk_type, Ids) elif el._type.startswith('c2d8') or el._type.startswith('s3d8'): Ids = vtk.vtkIdList() Ids.InsertNextId(el._nodelist[0].give_rank()) Ids.InsertNextId(el._nodelist[2].give_rank()) Ids.InsertNextId(el._nodelist[4].give_rank()) Ids.InsertNextId(el._nodelist[6].give_rank()) Ids.InsertNextId(el._nodelist[1].give_rank()) Ids.InsertNextId(el._nodelist[3].give_rank()) Ids.InsertNextId(el._nodelist[5].give_rank()) Ids.InsertNextId(el._nodelist[7].give_rank()) vtk_mesh.InsertNextCell(vtk_type, Ids) return vtk_mesh
import vtk # create a rendering window and renderer ren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) # create a renderwindowinteractor iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) # Create the points fot the lines. points = vtk.vtkPoints() points.InsertPoint(0, 0, 0, 1) points.InsertPoint(1, 1, 0, 0) points.InsertPoint(2, 0, 1, 0) points.InsertPoint(3, 1, 1, 1) # Create line1 line1 = vtk.vtkLine() line1.GetPointIds().SetId(0, 0) line1.GetPointIds().SetId(1, 1) # Create line2 line2 = vtk.vtkLine() line2.GetPointIds().SetId(0, 2) line2.GetPointIds().SetId(1, 3) # Create a cellArray containing the lines lines = vtk.vtkCellArray() lines.InsertNextCell(line1)
import vtk from vtk.test import Testing from vtk.util.misc import vtkGetDataRoot VTK_DATA_ROOT = vtkGetDataRoot() # Prevent .pyc files being created. # Stops the vtk source being polluted # by .pyc files. sys.dont_write_bytecode = True import backdrop # Contour every quadratic cell type # Create a scene with one of each cell type. # QuadraticEdge edgePoints = vtk.vtkPoints() edgePoints.SetNumberOfPoints(3) edgePoints.InsertPoint(0, 0, 0, 0) edgePoints.InsertPoint(1, 1.0, 0, 0) edgePoints.InsertPoint(2, 0.5, 0.25, 0) edgeScalars = vtk.vtkFloatArray() edgeScalars.SetNumberOfTuples(3) edgeScalars.InsertValue(0, 0.0) edgeScalars.InsertValue(1, 0.0) edgeScalars.InsertValue(2, 0.9) aEdge = vtk.vtkQuadraticEdge() aEdge.GetPointIds().SetId(0, 0) aEdge.GetPointIds().SetId(1, 1) aEdge.GetPointIds().SetId(2, 2) aEdgeGrid = vtk.vtkUnstructuredGrid() aEdgeGrid.Allocate(1, 1)
def cap_polydata_openings(poly, size): """ Cap the PolyData openings with acceptable mesh quality Args: poly: VTK PolyData to cap size: edge size of the cap mesh Returns: poly: capped VTK PolyData """ # TRY NOT USE TO USE THE POINT IDS, START FROM FEATURE EDGE DIRECTLY SINCE IT REQUIRES THE BOUNDARY POLYDATA #import matplotlib.pyplot as plt from vtk.util.numpy_support import vtk_to_numpy, numpy_to_vtk import os def _plot_points(points): fig = plt.figure() ax = fig.add_subplot(111, projection='3d') ax.scatter(points[:, 0], points[:, 1], points[:, 2]) plt.show() def _add_nodes_to_cap(vtkPts, size): """ Add uniformed points to cap """ points = vtk_to_numpy(vtkPts.GetData()) num = points.shape[0] #_plot_points(points) ctr = np.mean(points, axis=0) length = np.mean(np.linalg.norm(points - ctr, axis=1)) r = np.linspace(0.5 * size / length, (length - size * 0.8) / length, int(np.floor(length / size))) addedPts = vtk.vtkPoints() for rf in r: newPts = vtk.vtkPoints() newPts.SetData(numpy_to_vtk((points - ctr) * rf + ctr)) addedPts.InsertPoints(addedPts.GetNumberOfPoints(), newPts.GetNumberOfPoints(), 0, newPts) ptsPly = vtk.vtkPolyData() ptsPly.SetPoints(addedPts) vertexFilter = vtk.vtkVertexGlyphFilter() vertexFilter.SetInputData(ptsPly) vertexFilter.Update() ptsPly = vertexFilter.GetOutput() cleanedPts = clean_polydata(ptsPly, size * 0.01) vtkPts.InsertPoints(vtkPts.GetNumberOfPoints(), cleanedPts.GetNumberOfPoints(), 0, cleanedPts.GetPoints()) #_plot_points(vtk_to_numpy(vtkPts.GetData())) return vtkPts def _delaunay_2d(vtkPts, boundary): """ Delaunay 2D on input points """ vtkPtsPly = vtk.vtkPolyData() vtkPtsPly.SetPoints(vtkPts) ids, pt_list = oriented_pointset_on_boundary(boundary) polygon = vtk.vtkCellArray() polygon.InsertNextCell(len(ids)) for i in ids: polygon.InsertCellPoint(i) vtkPtsPly.SetPolys(polygon) delaunay = vtk.vtkDelaunay2D() delaunay.SetInputData(vtkPtsPly) delaunay.SetSourceData(vtkPtsPly) delaunay.SetTolerance(0.002) delaunay.Update() return delaunay.GetOutput() #tag polydata tag_id = 1 poly = tag_polydata(poly, tag_id) edges = find_boundary_edges(poly) components = separate_disconnected_polydata(edges) id_lists = [None] * len(components) pt_lists = [None] * len(components) for i in range(len(id_lists)): id_lists[i] = find_point_correspondence(poly, components[i].GetPoints()) pt_lists[i] = vtk.vtkPoints() pt_lists[i].DeepCopy(components[i].GetPoints()) print('Found %d points for boundary %d\n' % (len(id_lists[i]), i)) cap_pts_list = list() for boundary, ids, pts in zip(components, id_lists, pt_lists): cap_pts = _add_nodes_to_cap(pts, size) cap_pts_list.append(cap_pts) cap = _delaunay_2d(cap_pts, boundary) #cap = cutSurfaceWithPolygon(cap, boundary) #tag the caps tag_id += 1 cap = tag_polydata(cap, tag_id) poly = append_polydata(poly, cap) #cap_pts_ids = list() #for cap_pts in cap_pts_list: # cap_pts_ids.append(find_point_correspondence(poly,cap_pts)) poly = fix_polydata_normals(poly) return poly
def create_surface(): path_directory = 'PATH2D/' #elevation_data = np.loadtxt(path_directory + 'Ground_Rock2D.txt', delimiter = ',') topography = np.loadtxt(path_directory + 'Ground_Rock2D_2.txt') # topography *= 10 #elevation_data = elevation_data[:,1] #elevation_data *= 100 #width = elevation_data.shape[0] #width = 30 #topography = np.repeat(elevation_data, width).reshape((width, elevation_data.shape[0])) m = topography.shape[0] n = topography.shape[1] # Define points, triangles and colors points = vtk.vtkPoints() triangles = vtk.vtkCellArray() # Build the meshgrid manually count = 0 for i in range(m-1): for j in range(n-1): z1 = topography[i][j] z2 = topography[i][j+1] z3 = topography[i+1][j] # Triangle 1 points.InsertNextPoint(i, j, z1) points.InsertNextPoint(i, (j+1), z2) points.InsertNextPoint((i+1), j, z3) triangle = vtk.vtkTriangle() triangle.GetPointIds().SetId(0, count) triangle.GetPointIds().SetId(1, count + 1) triangle.GetPointIds().SetId(2, count + 2) triangles.InsertNextCell(triangle) z1 = topography[i][j+1] z2 = topography[i+1][j+1] z3 = topography[i+1][j] # Triangle 2 points.InsertNextPoint(i, (j+1), z1) points.InsertNextPoint((i+1), (j+1), z2) points.InsertNextPoint((i+1), j, z3) triangle = vtk.vtkTriangle() triangle.GetPointIds().SetId(0, count + 3) triangle.GetPointIds().SetId(1, count + 4) triangle.GetPointIds().SetId(2, count + 5) count += 6 triangles.InsertNextCell(triangle) # Create a polydata object trianglePolyData = vtk.vtkPolyData() # Add the geometry and topology to the polydata trianglePolyData.SetPoints(points) #trianglePolyData.GetPointData().SetScalars(colors) trianglePolyData.SetPolys(triangles) # Clean the polydata so that the edges are shared ! cleanPolyData = vtk.vtkCleanPolyData() cleanPolyData.SetInputData(trianglePolyData) # Use a filter to smooth the data (will add triangles and smooth) smooth_loop = vtk.vtkLoopSubdivisionFilter() smooth_loop.SetNumberOfSubdivisions(3) smooth_loop.SetInputConnection(cleanPolyData.GetOutputPort()) # Create a mapper and actor for smoothed dataset mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(smooth_loop.GetOutputPort()) actor_loop = vtk.vtkActor() actor_loop.SetMapper(mapper) actor_loop.GetProperty().SetInterpolationToFlat() # Update the pipeline so that vtkCellLocator finds cells ! smooth_loop.Update() # Define a cellLocator to be able to compute intersections between lines # and the surface locator = vtk.vtkCellLocator() locator.SetDataSet(smooth_loop.GetOutput()) locator.BuildLocator() transform = vtk.vtkTransform() transform.Scale((0.06, 1, 1)) transformFilter = vtk.vtkTransformPolyDataFilter() transformFilter.SetTransform(transform) actor_loop.SetUserTransform(transform) # Visualize # renderer = vtk.vtkRenderer() # renderWindow = vtk.vtkRenderWindow() # renderWindow.AddRenderer(renderer) # renderWindowInteractor = vtk.vtkRenderWindowInteractor() # renderWindowInteractor.SetRenderWindow(renderWindow) return actor_loop # Add actors and render # renderer.AddActor(actor_loop) # # renderer.SetBackground(1, 1, 1) # Background color white # renderWindow.SetSize(800, 800) # renderWindow.Render() # renderWindowInteractor.Start()
def visualizeTracks(tracker, seed): # Input the seed to the tracker object tracker.set_seeds(seed) # Run the tracker # This step will create N tracks if seed is a 3xN matrix tractogram = tracker.run() # Convert the first track to a vtkActor, i.e., tractogram[0] is the track # computed for the first seed # return trk2vtkActor(tractogram[0]) # renderer.AddActor(trkActor) # convert trk to vtkPolyData trk = np.transpose(np.asarray(tractogram[0])) numberOfPoints = trk.shape[0] points = vtk.vtkPoints() lines = vtk.vtkCellArray() colors = vtk.vtkFloatArray() colors.SetNumberOfComponents(4) colors.SetName("tangents") k = 0 lines.InsertNextCell(numberOfPoints) for j in range(numberOfPoints): points.InsertNextPoint(trk[j, :]) lines.InsertCellPoint(k) k = k + 1 if j < (numberOfPoints - 1): direction = trk[j + 1, :] - trk[j, :] direction = direction / np.linalg.norm(direction) colors.InsertNextTuple( np.abs([direction[0], direction[1], direction[2], 1])) else: colors.InsertNextTuple( np.abs([direction[0], direction[1], direction[2], 1])) trkData = vtk.vtkPolyData() trkData.SetPoints(points) trkData.SetLines(lines) trkData.GetPointData().SetScalars(colors) # make it a tube trkTube = vtk.vtkTubeFilter() trkTube.SetRadius(0.1) trkTube.SetNumberOfSides(4) trkTube.SetInputData(trkData) trkTube.Update() # mapper trkMapper = vtk.vtkPolyDataMapper() trkMapper.SetInputData(trkTube.GetOutput()) # actor trkActor = vtk.vtkActor() trkActor.SetMapper(trkMapper) return trkActor
def write_data(self, deck, problem, ccm_class): num_nodes = deck.num_nodes for t in range(0, deck.time_steps, self.slice_length): writer = vtk.vtkXMLUnstructuredGridWriter() writer.SetFileName(self.path + "output_" + str(t) + ".vtu") grid = vtk.vtkUnstructuredGrid() points = vtk.vtkPoints() points.SetNumberOfPoints(num_nodes) points.SetDataTypeToDouble() for i in range(0, num_nodes): act = problem.y if deck.dim == 1: points.InsertPoint(i, act[i][0][t], 0., 0.) if deck.dim == 2: points.InsertPoint(i, act[i][0][t], act[i][1][t], 0.) if deck.dim == 3: points.InsertPoint(i, act[i][0][t], act[i][1][t], act[i][2][t]) grid.SetPoints(points) dataOut = grid.GetPointData() for out_type in self.types: if out_type == "Displacement": array = vtk.vtkDoubleArray() array.SetName("Displacement") array.SetNumberOfComponents(deck.dim) array.SetNumberOfTuples(num_nodes) act = problem.y for i in range(num_nodes): if deck.dim == 1: array.SetTuple1( i, act[i][0][t] - deck.geometry.nodes[i][0]) if deck.dim == 2: array.SetTuple2( i, act[i][0][t] - deck.geometry.nodes[i][0], act[i][1][t] - deck.geometry.nodes[i][1]) array.SetComponentName(0, "d_x") array.SetComponentName(1, "d_y") dataOut.AddArray(array) if out_type == "Neighbors": array = vtk.vtkIntArray() array.SetName("Neighbors") array.SetNumberOfComponents(1) array.SetNumberOfTuples(num_nodes) for i in range(num_nodes): array.SetTuple1( i, len(problem.neighbors.get_index_x_family(i))) dataOut.AddArray(array) if out_type == "Force": array = vtk.vtkDoubleArray() array.SetName("Volume_Force") array.SetNumberOfComponents(deck.dim) array.SetNumberOfTuples(num_nodes) force = problem.force_int #print force for i in range(num_nodes): if deck.dim == 1: array.SetTuple1(i, force[i][0][t]) if deck.dim == 2: array.SetTuple2(i, force[i][0][t], force[i][1][t]) array.SetComponentName(0, "f_x") array.SetComponentName(1, "f_y") dataOut.AddArray(array) if out_type == "Conditions": for con in deck.conditions: array = vtk.vtkIntArray() array.SetName("Condition_" + con.type + "_" + str(con.value) + "_" + str(con.direction)) array.SetNumberOfComponents(1) array.SetNumberOfTuples(num_nodes) for i in range(num_nodes): if i not in con.id: array.SetTuple1(i, 0) else: array.SetTuple1(i, 1) dataOut.AddArray(array) if out_type == "Volume_Force": force = problem.force_int for con in deck.conditions: if con.type == "Force": result_x = 0. result_y = 0. result_z = 0. for i in con.id: index = int(i) if deck.dim >= 1: result_x += force[index][0][ t] * deck.geometry.volumes[index] if deck.dim >= 2: result_y += force[index][1][ t] * deck.geometry.volumes[index] array.SetComponentName(0, "f_x") array.SetComponentName(1, "f_y") if deck.dim >= 3: result_z += force[index][2][ t] * deck.geometry.volumes[index] array.SetComponentName(2, "f_z") array = vtk.vtkDoubleArray() array.SetName("Volume_" + con.type + "_" + str(con.value) + "_" + str(con.direction)) array.SetNumberOfComponents(deck.dim) array.SetNumberOfTuples(num_nodes) for i in range(num_nodes): if i in con.id: if deck.dim == 1: array.SetTuple1(i, result_x) if deck.dim == 2: array.SetTuple2( i, result_x, result_y) if deck.dim == 3: array.SetTuple3( i, result_x, result_y, result_z) else: if deck.dim == 1: array.SetTuple1(i, 0.) if deck.dim == 2: array.SetTuple2(i, 0., 0.) if deck.dim == 3: array.SetTuple3(i, 0., 0., 0.) dataOut.AddArray(array) if out_type == "Strain": array = vtk.vtkDoubleArray() array.SetName("Strain") if deck.dim == 1: array.SetNumberOfComponents(1) if deck.dim == 2: array.SetNumberOfComponents(3) if deck.dim == 3: array.SetNumberOfComponents(6) array.SetNumberOfTuples(num_nodes) strain = ccm_class.global_strain[:, :, 1] for i in range(num_nodes): if deck.dim == 1: array.SetComponentName(0, "epsil_xx") array.SetTuple1(i, strain[i, 0]) if deck.dim == 2: xx = strain[i * deck.dim, 0] xy = strain[i * deck.dim, 1] yy = strain[i * deck.dim + 1, 1] array.SetTuple3(i, xx, yy, xy) array.SetComponentName(0, "epsil_xx") array.SetComponentName(1, "epsil_yy") array.SetComponentName(2, "epsil_xy") if deck.dim == 3: xx = strain[i * deck.dim, 0] xy = strain[i * deck.dim, 1] yy = strain[i * deck.dim + 1, 1] yz = strain[i * deck.dim + 1, 2] xz = strain[i * deck.dim, 2] zz = strain[i * deck.dim + 2, 2] array.SetTuple6(i, xx, yy, zz, yz, xz, xy) array.SetComponentName(0, "epsil_xx") array.SetComponentName(1, "epsil_yy") array.SetComponentName(2, "epsil_zz") array.SetComponentName(3, "epsil_yz") array.SetComponentName(4, "epsil_xz") array.SetComponentName(5, "epsil_xy") dataOut.AddArray(array) if out_type == "Stress": array = vtk.vtkDoubleArray() array.SetName("Stress") if deck.dim == 1: array.SetNumberOfComponents(1) if deck.dim == 2: array.SetNumberOfComponents(3) if deck.dim == 3: array.SetNumberOfComponents(6) array.SetNumberOfTuples(num_nodes) stress = ccm_class.global_stress[:, :, 1] for i in range(num_nodes): if deck.dim == 1: array.SetComponentName(0, "sigma_xx") array.SetTuple1(i, strain[i, 0]) if deck.dim == 2: xx = stress[i * deck.dim, 0] xy = stress[i * deck.dim, 1] yy = stress[i * deck.dim + 1, 1] array.SetTuple3(i, xx, yy, xy) array.SetComponentName(0, "sigma_xx") array.SetComponentName(1, "sigma_yy") array.SetComponentName(2, "sigma_xy") if deck.dim == 3: xx = stress[i * deck.dim, 0] xy = stress[i * deck.dim, 1] yy = stress[i * deck.dim + 1, 1] yz = stress[i * deck.dim + 1, 2] xz = stress[i * deck.dim, 2] zz = stress[i * deck.dim + 2, 2] array.SetTuple6(i, xx, yy, zz, yz, xz, xy) array.SetComponentName(0, "sigma_xx") array.SetComponentName(1, "sigma_yy") array.SetComponentName(2, "sigma_zz") array.SetComponentName(3, "sigma_yz") array.SetComponentName(4, "sigma_xz") array.SetComponentName(5, "sigma_xy") dataOut.AddArray(array) if out_type == "Strain_DIC": array = vtk.vtkDoubleArray() array.SetName("Strain_DIC") array.SetNumberOfComponents(3) array.SetNumberOfTuples(num_nodes) for i in range(num_nodes): xx = deck.geometry.strain[i][0] xy = deck.geometry.strain[i][2] yy = deck.geometry.strain[i][1] array.SetTuple3(i, xx, yy, xy) array.SetComponentName(0, "epsil_xx") array.SetComponentName(1, "epsil_yy") array.SetComponentName(2, "epsil_xy") dataOut.AddArray(array) if out_type == "Strain_Error": array = vtk.vtkDoubleArray() array.SetName("Strain_Error") array.SetNumberOfComponents(3) array.SetNumberOfTuples(num_nodes) strain = ccm_class.global_strain[:, :, 1] for i in range(num_nodes): xx = abs(deck.geometry.strain[i][0] - strain[i * deck.dim, 0]) xy = abs(deck.geometry.strain[i][2] - strain[i * deck.dim, 1]) yy = abs(deck.geometry.strain[i][1] - strain[i * deck.dim + 1, 1]) array.SetTuple3(i, xx, yy, xy) array.SetComponentName(0, "error_xx") array.SetComponentName(1, "error_yy") array.SetComponentName(2, "error_xy") dataOut.AddArray(array) if out_type == "Strain_Energy": array = vtk.vtkDoubleArray() array.SetName("Strain_Energy") array.SetNumberOfComponents(1) array.SetNumberOfTuples(num_nodes) strain_energy = problem.strain_energy for i in range(num_nodes): array.SetTuple1(i, strain_energy[i]) dataOut.AddArray(array) writer.SetInputData(grid) writer.GetCompressor().SetCompressionLevel(0) writer.SetDataModeToAscii() writer.Write()
import vtk from vtk.test import Testing from vtk.util.misc import vtkGetDataRoot VTK_DATA_ROOT = vtkGetDataRoot() # A script to test the vtkLassoStencilSource reader = vtk.vtkPNGReader() reader.SetDataSpacing(0.8,0.8,1.5) reader.SetDataOrigin(0.0,0.0,0.0) reader.SetFileName("" + str(VTK_DATA_ROOT) + "/Data/fullhead15.png") reader.Update() shiftScale = vtk.vtkImageShiftScale() shiftScale.SetInputConnection(reader.GetOutputPort()) shiftScale.SetScale(0.2) shiftScale.Update() points1 = vtk.vtkPoints() points1.InsertNextPoint(80,50,0) points1.InsertNextPoint(100,90,0) points1.InsertNextPoint(200,50,0) points1.InsertNextPoint(230,100,0) points1.InsertNextPoint(150,170,0) points1.InsertNextPoint(110,170,0) points1.InsertNextPoint(80,50,0) points2 = vtk.vtkPoints() points2.InsertNextPoint(80,50,0) points2.InsertNextPoint(100,90,0) points2.InsertNextPoint(200,50,0) points2.InsertNextPoint(230,100,0) points2.InsertNextPoint(150,170,0) points2.InsertNextPoint(110,170,0) roiStencil1 = vtk.vtkLassoStencilSource()
# Read in vtk file ugrid = vtk_py.readUGrid(meshname + ".vtk") # Rotate mesh so that z = 0 at base ugridrot = vtk_py.rotateUGrid(ugrid, rx=0.0, ry=-90.0, rz=0.0, sx=1.0, sy=1.0, sz=1.0) vtk_py.writeUGrid(ugridrot, meshname + "_rot.vtk") # For some reason vtkPointLocator in extractFenicsBiVFacet will give error if precision is too high newpts = vtk.vtkPoints() for p in range(0, ugridrot.GetNumberOfPoints()): pt = [ ugridrot.GetPoints().GetPoint(p)[0], ugridrot.GetPoints().GetPoint(p)[1], ugridrot.GetPoints().GetPoint(p)[2] ] newpts.InsertNextPoint([round(pt[k], 5) for k in range(0, 3)]) ugridrot.SetPoints(newpts) # Extract fenics mesh fenics_mesh_ref, fenics_facet_ref, fenics_edge_ref = vtk_py.extractFeNiCsBiVFacet( ugridrot) dolfin.File("bivmesh.pvd") << fenics_mesh_ref dolfin.File("bivfacet.pvd") << fenics_facet_ref dolfin.File("bivedge.pvd") << fenics_edge_ref
def SWC_Processing(filename): print("Converting swc to vtp.") newname = filename[:-3] + "vtp" dataset = [text.split() for text in open(filename)] number = [int(line[0]) for line in dataset] colour = [int(line[1]) for line in dataset] positions = [[float(line[2]), float(line[3]), float(line[4])] for line in dataset] radius = [float(line[5]) for line in dataset] connection = [int(line[6]) for line in dataset] links = [[] for i in range(0, len(number))] for i in range(0, len(number)): if connection[i] > 0: nodenumber = number[i] - 1 linkedto = connection[i] - 1 links[nodenumber].append(linkedto) links[linkedto].append(nodenumber) nodes = [Node() for node in range(0, len(number))] [nodes[index].set_number(index) for index, rad in enumerate(radius)] [nodes[index].set_radius(rad) for index, rad in enumerate(radius)] [nodes[index].set_position(pos) for index, pos in enumerate(positions)] [nodes[index].set_ID(id) for index, id in enumerate(colour)] for index, link in enumerate(links): for con in link: nodes[index].add_connection(nodes[con]) nodes[con].add_connection(nodes[index]) outlets = [node for node in nodes if len(node.Connections) == 1] Vessels = [] ProcessedNodes = [] for BifurcationNode in outlets: # check connected vessels newvessels = list(set(BifurcationNode.Connections) - set(ProcessedNodes)) for node in newvessels: vessel = [] vessel.append(BifurcationNode) ProcessedNodes.append(BifurcationNode) currentnode = node while 1: numberconnection = len(currentnode.Connections) if numberconnection == 2: vessel.append(currentnode) ProcessedNodes.append(currentnode) currentnode = list(set(currentnode.Connections) - set(vessel))[0] elif numberconnection == 1: vessel.append(currentnode) ProcessedNodes.append(currentnode) Vessels.append(vessel) break else: vessel.append(currentnode) ProcessedNodes.append(currentnode) Vessels.append(vessel) break nodesvtk = vtk.vtkPoints() # pos vessels = vtk.vtkCellArray() # lines radius = vtk.vtkFloatArray() # radius nodeid = vtk.vtkIntArray() # id radius.SetNumberOfComponents(1) radius.SetName("Radius") nodeid.SetNumberOfComponents(1) nodeid.SetName("ID") # Add radius and position to data array for i in nodes: nodesvtk.InsertNextPoint(i.Position) radius.InsertNextValue(i.Radius) nodeid.InsertNextValue(i.ID) # Add vessels to cell array for vessel in Vessels: line = vtk.vtkLine() line.GetPointIds().SetNumberOfIds(len(vessel)) for i in range(0, len(vessel)): line.GetPointIds().SetId(i, vessel[i].Number) vessels.InsertNextCell(line) # Create a polydata to store everything in VesselsPolyData = vtk.vtkPolyData() # Add the nodes to the polydata VesselsPolyData.SetPoints(nodesvtk) # Add the vessels to the polydata VesselsPolyData.SetLines(vessels) # Assign radii and id to the nodes VesselsPolyData.GetPointData().SetScalars(radius) VesselsPolyData.GetPointData().AddArray(nodeid) # Write everything to a vtp file writer = vtk.vtkXMLPolyDataWriter() writer.SetFileName(newname) writer.SetInputData(VesselsPolyData) writer.Write()
def setWidgetView(self, widget): super(CenterLineView, self).setWidgetView(widget) point_array = self.parent.getData().pointSet point_data = npy.array(point_array.getData('Centerline')) if point_data is None or not point_data.shape[0]: return #self.spacing = [1, 1, 1] self.spacing = self.parent.getData().getResolution().tolist() self.spacing = [float(x) / self.spacing[-1] for x in self.spacing] point_data[:, :2] *= self.spacing[:2] self.renderer = vtk.vtkRenderer() self.render_window = widget.GetRenderWindow() self.render_window.AddRenderer(self.renderer) self.window_interactor = vtk.vtkRenderWindowInteractor() self.render_window.SetInteractor(self.window_interactor) self.center = [] self.center_mapper = [] self.center_actor = [] self.points = [] self.para_spline = [] self.spline_source = [] for cnt in range(3): self.center.append(vtk.vtkPolyData()) self.center_mapper.append(vtk.vtkPolyDataMapper()) self.center_actor.append(vtk.vtkActor()) self.points.append(vtk.vtkPoints()) self.para_spline.append(vtk.vtkParametricSpline()) self.spline_source.append(vtk.vtkParametricFunctionSource()) point = point_data[npy.where(npy.round(point_data[:, -1]) == cnt)] point = point[point[:, 2].argsort(), :] count = point.shape[0] if not count: continue self.points[cnt].SetNumberOfPoints(count) for i in range(count): self.points[cnt].SetPoint(i, point[i, 0], point[i, 1], point[i, 2]) self.para_spline[cnt].SetPoints(self.points[cnt]) self.spline_source[cnt].SetParametricFunction( self.para_spline[cnt]) numberOfOutputPoints = count * 10 self.spline_source[cnt].SetUResolution(numberOfOutputPoints) self.center_mapper[cnt].SetInput( self.spline_source[cnt].GetOutput()) self.center_mapper[cnt].ScalarVisibilityOff() self.center_actor[cnt].SetMapper(self.center_mapper[cnt]) color = [0, 0, 0] color[cnt] = 1 self.center_actor[cnt].GetProperty().SetColor( color[0], color[1], color[2]) self.renderer.AddViewProp(self.center_actor[cnt]) bound = npy.array( self.parent.getData().getData().shape)[::-1] * self.spacing outline_source = vtk.vtkOutlineSource() outline_source.SetBounds(0, bound[0], 0, bound[1], 0, bound[2]) mapOutline = vtk.vtkPolyDataMapper() mapOutline.SetInputConnection(outline_source.GetOutputPort()) outlineActor = vtk.vtkActor() outlineActor.SetMapper(mapOutline) outlineActor.GetProperty().SetColor(1, 1, 1) self.renderer.AddViewProp(outlineActor) self.renderer.ResetCamera() point = self.renderer.GetActiveCamera().GetFocalPoint() dis = self.renderer.GetActiveCamera().GetDistance() self.renderer.GetActiveCamera().SetViewUp(0, 0, 1) self.renderer.GetActiveCamera().SetPosition(point[0], point[1] - dis, point[2]) self.renderer.ResetCameraClippingRange() self.render_window.Render() # Manually set to trackball style self.window_interactor.SetKeyCode('t') self.window_interactor.CharEvent() self.window_interactor.GetInteractorStyle().AddObserver( "KeyPressEvent", self.KeyPressCallback) self.window_interactor.GetInteractorStyle().AddObserver( "CharEvent", self.KeyPressCallback)
def convertQuadScalarDataToVTK(mesh, Fspace, data, filename=[]): nsubspace = Fspace.num_sub_spaces() assert (nsubspace == 0), 'Only scalar space works' dim = mesh.geometry().dim() coord = Fspace.tabulate_dof_coordinates().reshape((-1, dim)) npts = int(len(coord)) my_first, my_last = Fspace.dofmap().ownership_range() x_dofs = np.arange(0, my_last - my_first) coord_dofs = np.arange(0, (my_last - my_first)) coord_reduce = coord[x_dofs] if (not isinstance(data, list)): points = vtk.vtkPoints() scalar = vtk.vtkFloatArray() scalar.SetNumberOfComponents(1) scalar.SetName("scalar") for x_dof, coord_dof in zip(x_dofs, coord_dofs): points.InsertNextPoint(coord_reduce[int(coord_dof)]) scalar.InsertNextValue(data.vector().array()[x_dof]) pdata = vtk.vtkPolyData() pdata.SetPoints(points) pdata.GetPointData().AddArray(scalar) glyphfilter = vtk.vtkVertexGlyphFilter() glyphfilter.AddInputData(pdata) glyphfilter.Update() else: points = vtk.vtkPoints() scalar_array = [] for p in range(0, len(data)): scalar_array.append(vtk.vtkFloatArray()) scalar_array[p].SetNumberOfComponents(3) scalar_array[p].SetName("scalar" + str(p)) for x_dof, coord_dof in zip(x_dofs, coord_dofs): points.InsertNextPoint(coord_reduce[int(coord_dof)]) for p in range(0, len(data)): scalar_array[p].InsertNextValue( data[p].vector().array()[x_dof]) pdata = vtk.vtkPolyData() pdata.SetPoints(points) for p in range(0, len(data)): pdata.GetPointData().AddArray(scalar_array[p]) glyphfilter = vtk.vtkVertexGlyphFilter() glyphfilter.AddInputData(pdata) glyphfilter.Update() if (not (not filename)): filename_ = filename + str(MPI.rank(mpi_comm_world())) + '.vtp' #vtk_py.writeXMLPData(glyphfilter.GetOutput(), filename_, verbose=False) vtk_py.writeXMLPData(pdata, filename_, verbose=False) if (MPI.rank(mpi_comm_world()) == 0): pvtufilename = filename + '.pvtp' pvtufile = open(pvtufilename, 'w') print >> pvtufile, "<?xml version=\"1.0\"?>" print >> pvtufile, "<VTKFile type=\"PPolyData\" version=\"0.1\">" print >> pvtufile, "<PPolyData GhostLevel=\"0\">" print >> pvtufile, "<PPointData Vectors=\"vector\">" print >> pvtufile, "<PDataArray type=\"Float32\" Name=\"vector\" NumberOfComponents=\"3\" />" print >> pvtufile, "</PPointData>" print >> pvtufile, "<PPoints>" print >> pvtufile, "<PDataArray type=\"Float32\" NumberOfComponents=\"3\"/>" print >> pvtufile, "</PPoints>" for p in range(0, MPI.size(mpi_comm_world())): print >> pvtufile, "<Piece Source=\"" + os.getcwd( ) + "/" + filename + str(p) + '.vtp' + "\" />" print >> pvtufile, "</PPolyData>" print >> pvtufile, "</VTKFile>" pvtufile.close() return pdata
def main(): colors = vtk.vtkNamedColors() # Set the colors. colors.SetColor("AzimuthArrowColor", [255, 77, 77, 255]) colors.SetColor("ElevationArrowColor", [77, 255, 77, 255]) colors.SetColor("RollArrowColor", [255, 255, 77, 255]) colors.SetColor("SpikeColor", [255, 77, 255, 255]) colors.SetColor("UpSpikeColor", [77, 255, 255, 255]) # Create a rendering window, renderer and interactor. ren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) # Create a camera model. camCS = vtk.vtkConeSource() camCS.SetHeight(1.5) camCS.SetResolution(12) camCS.SetRadius(0.4) camCBS = vtk.vtkCubeSource() camCBS.SetXLength(1.5) camCBS.SetZLength(0.8) camCBS.SetCenter(0.4, 0, 0) camAPD = vtk.vtkAppendPolyData() camAPD.AddInputConnection(camCBS.GetOutputPort()) camAPD.AddInputConnection(camCS.GetOutputPort()) camMapper = vtk.vtkPolyDataMapper() camMapper.SetInputConnection(camAPD.GetOutputPort()) camActor = vtk.vtkLODActor() camActor.SetMapper(camMapper) camActor.SetScale(2, 2, 2) # Draw the arrows. pd = vtk.vtkPolyData() ca = vtk.vtkCellArray() pts = vtk.vtkPoints() pts.InsertNextPoint(0, 1, 0) pts.InsertNextPoint(8, 1, 0) pts.InsertNextPoint(8, 2, 0) pts.InsertNextPoint(10, 0, 0) pts.InsertNextPoint(8, -2, 0) pts.InsertNextPoint(8, -1, 0) pts.InsertNextPoint(0, -1, 0) ca.InsertNextCell(7) ca.InsertCellPoint(0) ca.InsertCellPoint(1) ca.InsertCellPoint(2) ca.InsertCellPoint(3) ca.InsertCellPoint(4) ca.InsertCellPoint(5) ca.InsertCellPoint(6) pd.SetPoints(pts) pd.SetPolys(ca) pd2 = vtk.vtkPolyData() ca2 = vtk.vtkCellArray() pts2 = vtk.vtkPoints() pts2.InsertNextPoint(0, 1, 0) pts2.InsertNextPoint(8, 1, 0) pts2.InsertNextPoint(8, 2, 0) pts2.InsertNextPoint(10, 0.01, 0) ca2.InsertNextCell(4) ca2.InsertCellPoint(0) ca2.InsertCellPoint(1) ca2.InsertCellPoint(2) ca2.InsertCellPoint(3) pd2.SetPoints(pts2) pd2.SetLines(ca2) arrowIM = vtk.vtkImplicitModeller() arrowIM.SetInputData(pd) arrowIM.SetSampleDimensions(50, 20, 8) arrowCF = vtk.vtkContourFilter() arrowCF.SetInputConnection(arrowIM.GetOutputPort()) arrowCF.SetValue(0, 0.2) arrowWT = vtk.vtkWarpTo() arrowWT.SetInputConnection(arrowCF.GetOutputPort()) arrowWT.SetPosition(5, 0, 5) arrowWT.SetScaleFactor(0.85) arrowWT.AbsoluteOn() arrowT = vtk.vtkTransform() arrowT.RotateY(60) arrowT.Translate(-1.33198, 0, -1.479) arrowT.Scale(1, 0.5, 1) arrowTF = vtk.vtkTransformFilter() arrowTF.SetInputConnection(arrowWT.GetOutputPort()) arrowTF.SetTransform(arrowT) arrowMapper = vtk.vtkDataSetMapper() arrowMapper.SetInputConnection(arrowTF.GetOutputPort()) arrowMapper.ScalarVisibilityOff() # Draw the azimuth arrows. a1Actor = vtk.vtkLODActor() a1Actor.SetMapper(arrowMapper) a1Actor.SetPosition(-9, 0, -1) a1Actor.GetProperty().SetColor(colors.GetColor3d("AzimuthArrowColor")) a1Actor.GetProperty().SetSpecularColor(colors.GetColor3d("White")) a1Actor.GetProperty().SetSpecular(0.3) a1Actor.GetProperty().SetSpecularPower(20) a1Actor.GetProperty().SetAmbient(0.2) a1Actor.GetProperty().SetDiffuse(0.8) a2Actor = vtk.vtkLODActor() a2Actor.SetMapper(arrowMapper) a2Actor.RotateX(180) a2Actor.SetPosition(-9, 0, 1) a2Actor.GetProperty().SetColor(colors.GetColor3d("AzimuthArrowColor")) a2Actor.GetProperty().SetSpecularColor(colors.GetColor3d("White")) a2Actor.GetProperty().SetSpecular(0.3) a2Actor.GetProperty().SetSpecularPower(20) a2Actor.GetProperty().SetAmbient(0.2) a2Actor.GetProperty().SetDiffuse(0.8) # Draw the elevation arrows. a3Actor = vtk.vtkLODActor() a3Actor.SetMapper(arrowMapper) a3Actor.RotateX(-90) a3Actor.SetPosition(-9, -1, 0) a3Actor.GetProperty().SetColor(colors.GetColor3d("ElevationArrowColor")) a3Actor.GetProperty().SetSpecularColor(colors.GetColor3d("White")) a3Actor.GetProperty().SetSpecular(0.3) a3Actor.GetProperty().SetSpecularPower(20) a3Actor.GetProperty().SetAmbient(0.2) a3Actor.GetProperty().SetDiffuse(0.8) a4Actor = vtk.vtkLODActor() a4Actor.SetMapper(arrowMapper) a4Actor.RotateX(90) a4Actor.SetPosition(-9, 1, 0) a4Actor.GetProperty().SetColor(colors.GetColor3d("ElevationArrowColor")) a4Actor.GetProperty().SetSpecularColor(colors.GetColor3d("White")) a4Actor.GetProperty().SetSpecular(0.3) a4Actor.GetProperty().SetSpecularPower(20) a4Actor.GetProperty().SetAmbient(0.2) a4Actor.GetProperty().SetDiffuse(0.8) # Draw the DOP. arrowT2 = vtk.vtkTransform() arrowT2.Scale(1, 0.6, 1) arrowT2.RotateY(90) arrowTF2 = vtk.vtkTransformPolyDataFilter() arrowTF2.SetInputData(pd2) arrowTF2.SetTransform(arrowT2) arrowREF = vtk.vtkRotationalExtrusionFilter() arrowREF.SetInputConnection(arrowTF2.GetOutputPort()) arrowREF.CappingOff() arrowREF.SetResolution(30) spikeMapper = vtk.vtkPolyDataMapper() spikeMapper.SetInputConnection(arrowREF.GetOutputPort()) a5Actor = vtk.vtkLODActor() a5Actor.SetMapper(spikeMapper) a5Actor.SetScale(0.3, 0.3, 0.6) a5Actor.RotateY(-90) a5Actor.SetPosition(-8, 0, 0) a5Actor.GetProperty().SetColor(colors.GetColor3d("SpikeColor")) a5Actor.GetProperty().SetSpecularColor(colors.GetColor3d("White")) a5Actor.GetProperty().SetSpecular(0.3) a5Actor.GetProperty().SetAmbient(0.2) a5Actor.GetProperty().SetDiffuse(0.8) a5Actor.GetProperty().SetSpecularPower(20) a7Actor = vtk.vtkLODActor() a7Actor.SetMapper(spikeMapper) a7Actor.SetScale(0.2, 0.2, 0.7) a7Actor.RotateZ(90) a7Actor.RotateY(-90) a7Actor.SetPosition(-9, 1, 0) a7Actor.GetProperty().SetColor(colors.GetColor3d("UpSpikeColor")) a7Actor.GetProperty().SetSpecularColor(colors.GetColor3d("White")) a7Actor.GetProperty().SetSpecular(0.3) a7Actor.GetProperty().SetAmbient(0.2) a7Actor.GetProperty().SetDiffuse(0.8) a7Actor.GetProperty().SetSpecularPower(20) # Focal point. ss = vtk.vtkSphereSource() ss.SetRadius(0.5) fpMapper = vtk.vtkPolyDataMapper() fpMapper.SetInputConnection(ss.GetOutputPort()) fpActor = vtk.vtkLODActor() fpActor.SetMapper(fpMapper) fpActor.SetPosition(-9, 0, 0) fpActor.GetProperty().SetSpecularColor(colors.GetColor3d("White")) fpActor.GetProperty().SetSpecular(0.3) fpActor.GetProperty().SetAmbient(0.2) fpActor.GetProperty().SetDiffuse(0.8) fpActor.GetProperty().SetSpecularPower(20) # Create the roll arrows. arrowWT2 = vtk.vtkWarpTo() arrowWT2.SetInputConnection(arrowCF.GetOutputPort()) arrowWT2.SetPosition(5, 0, 2.5) arrowWT2.SetScaleFactor(0.95) arrowWT2.AbsoluteOn() arrowT3 = vtk.vtkTransform() arrowT3.Translate(-2.50358, 0, -1.70408) arrowT3.Scale(0.5, 0.3, 1) arrowTF3 = vtk.vtkTransformFilter() arrowTF3.SetInputConnection(arrowWT2.GetOutputPort()) arrowTF3.SetTransform(arrowT3) arrowMapper2 = vtk.vtkDataSetMapper() arrowMapper2.SetInputConnection(arrowTF3.GetOutputPort()) arrowMapper2.ScalarVisibilityOff() # Draw the roll arrows. a6Actor = vtk.vtkLODActor() a6Actor.SetMapper(arrowMapper2) a6Actor.RotateZ(90) a6Actor.SetPosition(-4, 0, 0) a6Actor.SetScale(1.5, 1.5, 1.5) a6Actor.GetProperty().SetColor(colors.GetColor3d("RollArrowColor")) a6Actor.GetProperty().SetSpecularColor(colors.GetColor3d("White")) a6Actor.GetProperty().SetSpecular(0.3) a6Actor.GetProperty().SetSpecularPower(20) a6Actor.GetProperty().SetAmbient(0.2) a6Actor.GetProperty().SetDiffuse(0.8) # Add the actors to the renderer, set the background and size. ren.AddActor(camActor) ren.AddActor(a1Actor) ren.AddActor(a2Actor) ren.AddActor(a3Actor) ren.AddActor(a4Actor) ren.AddActor(a5Actor) ren.AddActor(a6Actor) ren.AddActor(a7Actor) ren.AddActor(fpActor) ren.SetBackground(colors.GetColor3d("SlateGray")) renWin.SetSize(640, 480) # Render the image. cam1 = (ren.GetActiveCamera()) ren.ResetCamera() cam1.Azimuth(150) cam1.Elevation(30) cam1.Dolly(1.5) ren.ResetCameraClippingRange() # Create a TextActor for Yaw (a1 and a2 actor's color). text = vtk.vtkTextActor() text.SetInput("Yaw") tprop = text.GetTextProperty() tprop.SetFontFamilyToArial() tprop.ShadowOff() tprop.SetLineSpacing(1.0) tprop.SetFontSize(36) tprop.SetColor(a1Actor.GetProperty().GetColor()) text.SetDisplayPosition(20, 50) ren.AddActor2D(text) # Create a TextActor for Pitch (a3 and a4 actor's color). text2 = vtk.vtkTextActor() text2.SetInput("Pitch") tprop = text2.GetTextProperty() tprop.SetFontFamilyToArial() tprop.ShadowOff() tprop.SetLineSpacing(1.0) tprop.SetFontSize(36) tprop.SetColor(a3Actor.GetProperty().GetColor()) text2.SetDisplayPosition(20, 100) ren.AddActor2D(text2) # Create a TextActor for roll (a6 actor's color). text3 = vtk.vtkTextActor() text3.SetInput("Roll") tprop = text3.GetTextProperty() tprop.SetFontFamilyToArial() tprop.ShadowOff() tprop.SetLineSpacing(1.0) tprop.SetFontSize(36) tprop.SetColor(a6Actor.GetProperty().GetColor()) text3.SetDisplayPosition(20, 150) ren.AddActor2D(text3) iren.Initialize() iren.Start()
def get_frustum_actor(frustum_points): # Create frustum with lines pts = vtk.vtkPoints() origin = [0.0, 0.0, 0.0] pts.InsertNextPoint(origin) print(len(frustum_points)) for idx in range(0,len(frustum_points)): print("point") pts.InsertNextPoint(frustum_points[idx]) # Setup color green = [0, 255, 0] # Setup the colors array colors = vtk.vtkUnsignedCharArray() colors.SetNumberOfComponents(3) colors.SetName("Colors") for idx in range(0,8): # Add the colors to the colors array colors.InsertNextTypedTuple(green) # Create the lines # Create the first line (between Origin and P0) line0 = vtk.vtkLine() line0.GetPointIds().SetId(0,0) # the second 0 is the index of the Origin in the vtkPoints line0.GetPointIds().SetId(1,1) # the second 1 is the index of P0 in the vtkPoints # Create the second line (between Origin and P1) line1 = vtk.vtkLine() line1.GetPointIds().SetId(0,0) # the second 0 is the index of the Origin in the vtkPoints line1.GetPointIds().SetId(1,2) # 2 is the index of P1 in the vtkPoints # Next two lines from origin line2 = vtk.vtkLine() line2.GetPointIds().SetId(0,0) line2.GetPointIds().SetId(1,3) line3 = vtk.vtkLine() line3.GetPointIds().SetId(0,0) line3.GetPointIds().SetId(1,4) # Create box lines line4 = vtk.vtkLine() line4.GetPointIds().SetId(0,1) line4.GetPointIds().SetId(1,2) line5 = vtk.vtkLine() line5.GetPointIds().SetId(0,2) line5.GetPointIds().SetId(1,3) line6 = vtk.vtkLine() line6.GetPointIds().SetId(0,3) line6.GetPointIds().SetId(1,4) line7 = vtk.vtkLine() line7.GetPointIds().SetId(0,4) line7.GetPointIds().SetId(1,1) # Create a cell array to store the lines in and add the lines to it lines = vtk.vtkCellArray() lines.InsertNextCell(line0) lines.InsertNextCell(line1) lines.InsertNextCell(line2) lines.InsertNextCell(line3) lines.InsertNextCell(line4) lines.InsertNextCell(line5) lines.InsertNextCell(line6) lines.InsertNextCell(line7) # Create a polydata to store everything in linesPolyData = vtk.vtkPolyData() # Add the points to the dataset linesPolyData.SetPoints(pts) # Add the lines to the dataset linesPolyData.SetLines(lines) # Color the lines - associate the first component (red) of the # colors array with the first component of the cell array (line 0) # and the second component (green) of the colors array with the # second component of the cell array (line 1) linesPolyData.GetCellData().SetScalars(colors) # Visualize mapper = vtk.vtkPolyDataMapper() if vtk.VTK_MAJOR_VERSION <= 5: mapper.SetInput(linesPolyData) else: mapper.SetInputData(linesPolyData) actor = vtk.vtkActor() actor.SetMapper(mapper) return actor
def load_shabp_geometry(self, shabp_filename, name='main', plot=True): model_name = name self.gui.eid_maps[name] = {} self.gui.nid_maps[name] = {} #key = self.case_keys[self.icase] #case = self.result_cases[key] skip_reading = self.gui._remove_old_geometry(shabp_filename) if skip_reading: return self.model = read_shabp(shabp_filename, log=self.gui.log, debug=self.gui.debug) self.gui.model_type = 'shabp' # model.model_type out = self.model.get_points_elements_regions() nodes, elements, patches, components, impact, shadow = out #for nid,node in enumerate(nodes): #print "node[%s] = %s" %(nid,str(node)) nnodes = len(nodes) nelements = len(elements) self.gui.nnodes = nnodes self.gui.nelements = nelements #print("nnodes = ",self.nnodes) #print("nelements = ", self.nelements) grid = self.gui.grid grid.Allocate(nelements, 1000) points = vtk.vtkPoints() points.SetNumberOfPoints(nnodes) assert len(nodes) > 0 mmax = amax(nodes, axis=0) mmin = amin(nodes, axis=0) dim_max = (mmax - mmin).max() self.gui.create_global_axes(dim_max) for nid, node in enumerate(nodes): points.InsertPoint(nid, *node) assert len(elements) > 0 for unused_eid, element in enumerate(elements): (p1, p2, p3, p4) = element elem = vtkQuad() elem.GetPointIds().SetId(0, p1) elem.GetPointIds().SetId(1, p2) elem.GetPointIds().SetId(2, p3) elem.GetPointIds().SetId(3, p4) grid.InsertNextCell(elem.GetCellType(), elem.GetPointIds()) grid.SetPoints(points) grid.Modified() # loadShabpResults - regions/loads self.gui.scalar_bar_actor.VisibilityOn() self.gui.scalar_bar_actor.Modified() self.gui.isubcase_name_map = {1: ['S/HABP', '']} cases = OrderedDict() ID = 1 self.gui.log.debug("nNodes=%i nElements=%i" % (self.gui.nnodes, self.gui.nelements)) form, cases = self._fill_shabp_geometry_case(cases, ID, nodes, elements, patches, components, impact, shadow) nelements = len(elements) node_ids = np.arange(1, nnodes + 1, dtype='int32') element_ids = np.arange(1, nelements + 1, dtype='int32') self.gui.node_ids = node_ids self.gui.element_ids = element_ids self.gui._finish_results_io2(model_name, form, cases) self.gui.bkp = self.model
def load_shabp_geometry(self, shabp_filename, name='main', plot=True): self.parent.eid_maps[name] = {} self.parent.nid_maps[name] = {} #key = self.case_keys[self.icase] #case = self.result_cases[key] skip_reading = self.parent._remove_old_geometry(shabp_filename) if skip_reading: return self.model = read_shabp(shabp_filename, log=self.parent.log, debug=self.parent.debug) self.parent.model_type = 'shabp' # model.model_type nodes, elements, patches, components, impact, shadow = self.model.get_points_elements_regions( ) #for nid,node in enumerate(nodes): #print "node[%s] = %s" %(nid,str(node)) nnodes = len(nodes) self.nnodes = len(nodes) self.nelements = len(elements) #print("nnodes = ",self.nnodes) #print("nelements = ", self.nelements) self.parent.grid.Allocate(self.parent.nelements, 1000) points = vtk.vtkPoints() points.SetNumberOfPoints(self.parent.nnodes) assert len(nodes) > 0 mmax = amax(nodes, axis=0) mmin = amin(nodes, axis=0) dim_max = (mmax - mmin).max() self.parent.create_global_axes(dim_max) for nid, node in enumerate(nodes): points.InsertPoint(nid, *node) assert len(elements) > 0 for eid, element in enumerate(elements): (p1, p2, p3, p4) = element elem = vtkQuad() elem.GetPointIds().SetId(0, p1) elem.GetPointIds().SetId(1, p2) elem.GetPointIds().SetId(2, p3) elem.GetPointIds().SetId(3, p4) self.parent.grid.InsertNextCell(elem.GetCellType(), elem.GetPointIds()) self.parent.grid.SetPoints(points) self.parent.grid.Modified() if hasattr(self.parent.grid, 'Update'): # pragma: no cover self.parent.grid.Update() # loadShabpResults - regions/loads self.parent.scalarBar.VisibilityOn() self.parent.scalarBar.Modified() self.parent.isubcase_name_map = {1: ['S/HABP', '']} cases = OrderedDict() ID = 1 self.parent.log.debug("nNodes=%i nElements=%i" % (self.parent.nnodes, self.parent.nelements)) form, cases = self._fill_shabp_geometry_case(cases, ID, nodes, elements, patches, components, impact, shadow) self.parent._finish_results_io2(form, cases)
def addingVTKCoords(self): # adding coordinates vtk_coords = list(self.coord) self.points = vtk.vtkPoints() for vtk_coord in vtk_coords: self.points.InsertNextPoint(vtk_coord)
def ReducePolyData2D(inPoly, outPoly, closed): """ FIXME """ inPts = inPoly.GetPoints() if inPts is None: return 0 n = inPts.GetNumberOfPoints() if (n < 3): return 0 p0 = inPts.GetPoint(0) p1 = inPts.GetPoint(n - 1) minusNth = p0[0] == p1[0] and p0[1] == p1[1] and p0[2] == p1[2] if (minusNth and closed == 1): n = n - 1 # frenet unit tangent vector and state of kappa (zero or non-zero) f = n * [frenet((0.0, 0.0, 0.0), False)] # calculate the tangent vector by forward differences for i in range(n): p0 = inPts.GetPoint(i) p1 = inPts.GetPoint((i + 1) % n) tL = math.sqrt(vtk.vtkMath.Distance2BetweenPoints(p0, p1)) if (tL == 0.0): tL = 1.0 f[i].t = ((p1[0] - p0[0]) / tL, (p1[1] - p0[1]) / tL, (p1[2] - p0[2]) / tL) # calculate kappa from tangent vectors by forward differences # mark those points that have very low curvature eps = 1.0e-10 for i in range(n): t0 = f[i].t t1 = f[(i + 1) % n].t f[i].state = math.fabs(vtk.vtkMath.Dot(t0, t1) - 1.0) < eps tempPts = vtk.vtkPoints() # mark keepers ids = vtk.vtkIdTypeArray() # for now, insist on keeping the first point for closure ids.InsertNextValue(0) for i in range(1, n): pre = f[(i - 1 + n) % n].state # means fik != 1 cur = f[i].state # means fik = 1 nex = f[(i + 1) % n].state # possible vertex bend patterns for keep: pre cur nex # 0 0 1 # 0 1 1 # 0 0 0 # 0 1 0 # definite delete pattern # 1 1 1 keep = False if (pre and cur and nex): keep = False elif (not pre and not cur and nex): keep = True elif (not pre and cur and nex): keep = True elif (not pre and not cur and not nex): keep = True elif (not pre and cur and not nex): keep = True if (keep): ids.InsertNextValue(i) for i in range(ids.GetNumberOfTuples()): tempPts.InsertNextPoint(inPts.GetPoint(ids.GetValue(i))) if (closed == 1): tempPts.InsertNextPoint(inPts.GetPoint(ids.GetValue(0))) outPoly = ConvertPointSequenceToPolyData(tempPts, closed) ids = None #.Delete() tempPts = None #.Delete() return 1