def CreateCoords_versore(o, r): """ Ritorna una lista di attori contenenti i il sistema di coordinate: o = origine r = versore""" points = [] Lines=[] Polygon = vtk.vtkPolyData() ac=[] points = vtk.vtkPoints() points.SetNumberOfPoints(4) points.SetPoint(0, self.midPoint) points.SetPoint(1, [self.FrenetBinormalArray[0]+self.midPoint[0], self.FrenetBinormalArray[1]+self.midPoint[1], self.FrenetBinormalArray[2]+self.midPoint[2]]) points.SetPoint(2, [self.FrenetNormalArray[0]+self.midPoint[0], self.FrenetNormalArray[1]+self.midPoint[1], self.FrenetNormalArray[2]+self.midPoint[2]]) points.SetPoint(3, [self.FrenetTangentArray[0]+self.midPoint[0], self.FrenetTangentArray[1]+self.midPoint[1], self.FrenetTangentArray[2]+self.midPoint[2]]) points.SetPoint(0, o) points.SetPoint(1, [o[0]+r[0], o[1] , o[2]]) points.SetPoint(2, [o[0] , o[1]+r[1] , o[2]]) points.SetPoint(3, [o[0] , o[1] , o[2]+r[2]]) polyLine0 = vtk.vtkPolyLine() polyLine0.GetPointIds().SetNumberOfIds(2) polyLine0.GetPointIds().SetId(0,0) polyLine0.GetPointIds().SetId(1,1) polyLine1 = vtk.vtkPolyLine() polyLine1.GetPointIds().SetNumberOfIds(2) polyLine1.GetPointIds().SetId(0,0) polyLine1.GetPointIds().SetId(1,2) polyLine2 = vtk.vtkPolyLine() polyLine2.GetPointIds().SetNumberOfIds(2) polyLine2.GetPointIds().SetId(0,0) polyLine2.GetPointIds().SetId(1,3) cells0 = vtk.vtkCellArray() cells0.InsertNextCell(polyLine0) cells0.InsertNextCell(polyLine1) cells0.InsertNextCell(polyLine2) polyData = vtk.vtkPolyData() polyData.SetPoints(points) polyData.SetLines(cells0) ac=[] ac.append(CreateSphere(points.GetPoint(0), 0.05, [1, 1, 1])) ac.append(CreateSphere(points.GetPoint(1), 0.1, [1, 0, 0])) ac.append(CreateSphere(points.GetPoint(2), 0.1, [0, 1, 0])) ac.append(CreateSphere(points.GetPoint(3), 0.1, [0, 0, 1])) ac.append(CreateActor(polyData)) return ac
def create_polyline(points: List[Point3D]) -> PolyData: """Create a polyline from a list of points.""" # Create a vtkPoints container and store the points for all the lines pts = vtk.vtkPoints() for pt in points: pts.InsertNextPoint(tuple(pt)) # add all the points to lines dataset polyline = vtk.vtkPolyLine() polyline.GetPointIds().SetNumberOfIds(len(points)) for i in range(len(points)): polyline.GetPointIds().SetId(i, i) # Create a cell array to store the lines in and add the lines to it cells = vtk.vtkCellArray() cells.InsertNextCell(polyline) # Create a polydata to store everything in polydata = PolyData() # Add the points to the dataset polydata.SetPoints(pts) # Add the lines to the dataset polydata.SetLines(cells) return polydata
def __init__(self, parent, visualizer, **kws): """ Initialization """ self.x, self.y, self.z = -1, -1, -1 VisualizationModule.__init__(self, parent, visualizer, **kws) #self.name = "Scale bar" self.renew = 1 self.mapper = vtk.vtkDataSetMapper() self.actor = vtk.vtkActor() self.actor.SetMapper(self.mapper) self.width = 10 self.widthPx = 100 self.voxelSize = (1, 1, 1) self.renderer = self.parent.getRenderer() self.renderer.AddActor(self.actor) self.polyLine = vtk.vtkPolyLine() #self.mapper.SetInput(self.polyLine.GetOutput()) self.actor.GetProperty().SetColor(1, 1, 1) self.textActor = vtk.vtkTextActor() #self.textActor.ScaledTextOn() self.renderer.AddActor2D(self.textActor) iactor = self.wxrenwin.GetRenderWindow().GetInteractor() style = iactor.GetInteractorStyle() # style.AddObserver("StartInteractionEvent",self.updateLine) style.AddObserver("EndInteractionEvent", self.updateRendering)
def make_vtu_grid(self): all_points = vtkPoints() displacement = vtkDoubleArray() displacement.SetName('displacement') velocity = vtkDoubleArray() velocity.SetName('velocity') velocity.SetNumberOfComponents(3) ug = vtkUnstructuredGrid() ug.SetPoints(all_points) ug.GetPointData().SetScalars(displacement) ug.GetPointData().SetVectors(velocity) current_idx = 0 for fiber in itertools.chain(self.weft.fibers, self.warp.fibers): polyline = vtkPolyLine() for point in fiber.points: all_points.InsertNextPoint(point.coords.x, point.coords.y, point.coords.z) polyline.GetPointIds().InsertNextId(current_idx) displacement.InsertNextValue(point.data) velocity.InsertNextTuple3(point.velocity.x, point.velocity.y, point.velocity.z) current_idx += 1 ug.InsertNextCell(polyline.GetCellType(), polyline.GetPointIds()) return ug
def continentsVCS2VTK(fnm): """ This converts vcs continents files to vtkpolydata Author: Charles Doutriaux Input: vcs continent file name """ poly =vtk.vtkPolyData() cells = vtk.vtkCellArray() pts = vtk.vtkPoints() f=open(fnm) ln=f.readline() while ln.strip().split()!=["-99","-99"]: # Many lines, need to know number of points N = int(ln.split()[0]) # Now create and store these points n=0 npts = pts.GetNumberOfPoints() while n<N: ln=f.readline() while len(ln)>2: l,L=float(ln[:8]),float(ln[8:16]) pts.InsertNextPoint(L,l,0.0001) ln=ln[16:] n+=2 ln = vtk.vtkPolyLine() ln.GetPointIds().SetNumberOfIds(N/2) for i in range(N/2): ln.GetPointIds().SetId(i,i+npts) cells.InsertNextCell(ln) ln=f.readline() poly.SetPoints(pts) poly.SetLines(cells) return poly
def new_mesh_set(self, all_meshes): """ Define a new mesh set. This function must be called each time the number of meshes change Parameters ---------- all_meshes : MeshCollection One frame of mesh """ if isinstance(all_meshes, Mesh): mesh_tp = [] mesh_tp.append(all_meshes) all_meshes = mesh_tp if not isinstance(all_meshes, list): raise TypeError("Please send a list of mesh to update_mesh") self.all_meshes = all_meshes # Remove previous actors from the scene for actor in self.mesh_actors: self.parent_window.ren.RemoveActor(actor) self.mesh_actors = list() # Create the geometry of a point (the coordinate) points = vtkPoints() for (i, mesh) in enumerate(self.all_meshes): if mesh.time.size != 1: raise IndexError("Mesh should be from one frame only") points = vtkPoints() for j in range(mesh.channel.size): points.InsertNextPoint([0, 0, 0]) # Create an array for each triangle cell = vtkCellArray() for j in range(mesh.triangles.shape[1]): # For each triangle line = vtkPolyLine() line.GetPointIds().SetNumberOfIds(4) for k in range(len(mesh.triangles[:, j])): # For each index line.GetPointIds().SetId(k, mesh.triangles[k, j]) line.GetPointIds().SetId(3, mesh.triangles[0, j]) # Close the triangle cell.InsertNextCell(line) poly_line = vtkPolyData() poly_line.SetPoints(points) poly_line.SetLines(cell) # Create a mapper mapper = vtkPolyDataMapper() mapper.SetInputData(poly_line) # Create an actor self.mesh_actors.append(vtkActor()) self.mesh_actors[i].SetMapper(mapper) self.mesh_actors[i].GetProperty().SetColor(self.mesh_color) self.mesh_actors[i].GetProperty().SetOpacity(self.mesh_opacity) self.parent_window.ren.AddActor(self.mesh_actors[i]) self.parent_window.ren.ResetCamera() # Update marker position self.update_mesh(self.all_meshes)
def skippoints(polydata,nskippoints): """Generate a single cell line from points in idlist.""" # derive number of nodes numberofnodes = polydata.GetNumberOfPoints() - nskippoints # define points and line points = vtk.vtkPoints() polyline = vtk.vtkPolyLine() polyline.GetPointIds().SetNumberOfIds(numberofnodes) # assign id and x,y,z coordinates for i in range(nskippoints,polydata.GetNumberOfPoints()): pointid = i - nskippoints polyline.GetPointIds().SetId(pointid,pointid) point = polydata.GetPoint(i) points.InsertNextPoint(point) # define cell cells = vtk.vtkCellArray() cells.InsertNextCell(polyline) # add to polydata polyout = vtk.vtkPolyData() polyout.SetPoints(points) polyout.SetLines(cells) return polyout
def ArcActor(fromValue, to, rad=1.0, axis='z', n=20): fromValue = fromValue * pi / 180 to = to * pi / 180 angle = to - fromValue ppnts = vtk.vtkPoints() ppnts.SetNumberOfPoints(n) for i in range(0, n): theta = fromValue + i * angle / (n - 1) if axis == 'x': ppnts.InsertPoint(i, 0.0, cos(theta), sin(theta)) elif axis == 'y': ppnts.InsertPoint(i, sin(theta), 0.0, cos(theta)) elif axis == 'z': ppnts.InsertPoint(i, cos(theta), sin(theta), 0.0) pline = vtk.vtkPolyLine() pline.GetPointIds().SetNumberOfIds(n) for i in range(0, n): pline.GetPointIds().SetId(i, i) pdata = vtk.vtkPolyData() pdata.Allocate(1, 1) pdata.InsertNextCell(pline.GetCellType(), pline.GetPointIds()) pdata.SetPoints(ppnts) mapper = vtk.vtkPolyDataMapper() mapper.SetInput(pdata) actor = vtk.vtkActor() actor.SetMapper(mapper) actor.GetProperty().SetColor(1, 0, 0) return actor
def createLineCells(Nx, Ny, **kwargs): ''' Create lines corresponding to a Nx x Ny grid. Parameters: :Nx (int): Number of points in the first dimension :Ny (int): Number of points in the second dimension Keyword arguments: :cutsectionIsClosed (bool or [bool]): Flag to indicate whether to wrap around the indices This is useful for creating a cell distribution for a cylinder Can also be an array of bools each indicating whether each of the sections in the x-direction should be wrapped ''' cells = vtk.vtkCellArray() cutsectionIsClosed = kwargs.get('cutsectionIsClosed', True) for i in range(Nx): if isinstance(cutsectionIsClosed, bool): wrapAround = cutsectionIsClosed else: # Assume array like wrapAround = cutsectionIsClosed[i] and cutsectionIsClosed[i-1] cell = vtk.vtkPolyLine() startId = i*Ny if wrapAround: cell.GetPointIds().SetNumberOfIds(Ny+1) cell.GetPointIds().SetId(Ny, startId) else: cell.GetPointIds().SetNumberOfIds(Ny) for j in range(Ny): cell.GetPointIds().SetId(j, startId+j) cells.InsertNextCell(cell) return cells
def drawPolyLine(self, currentAnimationTime): #remove polyline cells older than lifetime if self.lifetimeEnabled and self.lifetime >= self.lifetimeMin: if (self.pdo.GetNumberOfCells() - self.lifetime) >= 0: #remove from the polyline cells older than lifetime self.pdo.DeleteCell(0) self.pdo.RemoveDeletedCells() aPolyLine = vtk.vtkPolyLine() aPolyLine.GetPointIds().SetNumberOfIds(self.heightCount) for j in range(0, self.heightCount): x = self.lon[currentAnimationTime] y = self.lat[currentAnimationTime] z = self.height[j] self.newPoints.InsertPoint(self.polyIndex + j, x, y, z) aPolyLine.GetPointIds().SetId(j, self.polyIndex + j) self.polyIndex += self.heightCount #Update the output polyline self.pdo.SetPoints(self.newPoints) self.pdo.InsertNextCell(aPolyLine.GetCellType(), aPolyLine.GetPointIds()) #timeCompare is unused for now, will be used to figure out wether the timesteps are played forward or backward self.timeCompare = currentAnimationTime
def createSegNodeFromContourPoints(segmentationNode, contours, name): # set up contour objects contoursPolyData = vtk.vtkPolyData() contourPoints = vtk.vtkPoints() contourLines = vtk.vtkCellArray() contoursPolyData.SetLines(contourLines) contoursPolyData.SetPoints(contourPoints) for contour in contours: startPointIndex = contourPoints.GetNumberOfPoints() contourLine = vtk.vtkPolyLine() linePointIds = contourLine.GetPointIds() for point in contour: linePointIds.InsertNextId(contourPoints.InsertNextPoint(point)) linePointIds.InsertNextId( startPointIndex) # make the contour line closed contourLines.InsertNextCell(contourLine) segment = slicer.vtkSegment() segment.SetName(name) # segment.SetColor(segmentColor) segment.AddRepresentation("Planar contour", contoursPolyData) segmentationNode.GetSegmentation().SetMasterRepresentationName( "Planar contour") segmentationNode.GetSegmentation().AddSegment(segment)
def main(): # Parse commandline arguments. args = _parse_args() # Check input file extensions. for fname in args.input: if not (fname.endswith('.h5') or fname.endswith('.binary')): raise ValueError("Input file names must either end with '.h5' or" "'.binary'.") # Make sure that the output filename ends with '.pvtp'. if not args.out: args.out = 'tracks.pvtp' elif os.path.splitext(args.out)[1] != '.pvtp': args.out = ''.join([args.out, '.pvtp']) # Import HDF library if HDF files are present for fname in args.input: if fname.endswith('.h5'): import h5py break # Initialize data arrays and offset. points = vtk.vtkPoints() cells = vtk.vtkCellArray() point_offset = 0 for fname in args.input: # Write coordinate values to points array. if fname.endswith('.binary'): track = open(fname, 'rb').read() coords = [ struct.unpack("ddd", track[24 * i:24 * (i + 1)]) for i in range(len(track) / 24) ] n_points = len(coords) for triplet in coords: points.InsertNextPoint(triplet) else: coords = h5py.File(fname).get('coordinates') n_points = coords.shape[0] for i in range(n_points): points.InsertNextPoint(coords[i, :]) # Create VTK line and assign points to line. line = vtk.vtkPolyLine() line.GetPointIds().SetNumberOfIds(n_points) for i in range(n_points): line.GetPointIds().SetId(i, point_offset + i) cells.InsertNextCell(line) point_offset += n_points data = vtk.vtkPolyData() data.SetPoints(points) data.SetLines(cells) writer = vtk.vtkXMLPPolyDataWriter() writer.SetInput(data) writer.SetFileName(args.out) writer.Write()
def draw(self, graphics): cell, pointnums = super(Line, self).draw(graphics) line = vtk.vtkPolyLine() line.GetPointIds().SetNumberOfIds(len(pointnums)) for i, p in enumerate(pointnums): line.GetPointIds().SetId(i, p) cell.InsertNextCell(line)
def write_vtk(self, datadir='data', file_name='spines.vtk', binary=False): """ Write the spines into a vtk file. call signature: write_vtk(datadir='data', file_name='spines.vtk', binary=False) Arguments: *datadir*: Target data directory. *file_name*: Target file name. *binary*: Write file in binary or ASCII format. """ import os as os try: import vtk as vtk except: print("Warning: no vtk library found.") writer = vtk.vtkPolyDataWriter() if binary: writer.SetFileTypeToBinary() else: writer.SetFileTypeToASCII() writer.SetFileName(os.path.join(datadir, file_name)) poly_data = vtk.vtkPolyData() points = vtk.vtkPoints() # Create the cell to store the lines in. cells = vtk.vtkCellArray() poly_lines = [] offset = 0 for line_idx in range(len(self.spines)): n_points = self.spines[line_idx].shape[0] poly_lines.append(vtk.vtkPolyLine()) poly_lines[-1].GetPointIds().SetNumberOfIds(n_points) for point_idx in range(n_points): points.InsertNextPoint(self.spines[line_idx][point_idx]) poly_lines[-1].GetPointIds().SetId(point_idx, point_idx + offset) cells.InsertNextCell(poly_lines[-1]) offset += n_points poly_data.SetPoints(points) poly_data.SetLines(cells) # Insure compatability between vtk 5 and 6. try: writer.SetInputData(poly_data) except: writer.SetInput(poly_data) writer.Write()
def main(): # Parse commandline arguments. args = _parse_args() # Check input file extensions. for fname in args.input: if not (fname.endswith('.h5') or fname.endswith('.binary')): raise ValueError("Input file names must either end with '.h5' or" "'.binary'.") # Make sure that the output filename ends with '.pvtp'. if not args.out: args.out = 'tracks.pvtp' elif os.path.splitext(args.out)[1] != '.pvtp': args.out = ''.join([args.out, '.pvtp']) # Import HDF library if HDF files are present for fname in args.input: if fname.endswith('.h5'): import h5py break # Initialize data arrays and offset. points = vtk.vtkPoints() cells = vtk.vtkCellArray() point_offset = 0 for fname in args.input: # Write coordinate values to points array. if fname.endswith('.binary'): track = open(fname, 'rb').read() coords = [struct.unpack("ddd", track[24*i : 24*(i+1)]) for i in range(len(track)/24)] n_points = len(coords) for triplet in coords: points.InsertNextPoint(triplet) else: coords = h5py.File(fname).get('coordinates') n_points = coords.shape[0] for i in range(n_points): points.InsertNextPoint(coords[i,:]) # Create VTK line and assign points to line. line = vtk.vtkPolyLine() line.GetPointIds().SetNumberOfIds(n_points) for i in range(n_points): line.GetPointIds().SetId(i, point_offset+i) cells.InsertNextCell(line) point_offset += n_points data = vtk.vtkPolyData() data.SetPoints(points) data.SetLines(cells) writer = vtk.vtkXMLPPolyDataWriter() writer.SetInput(data) writer.SetFileName(args.out) writer.Write()
def runPlugin(self): global ariadne global CubeLoader skelvp=ariadne.QRWin.viewports["skeleton_viewport"] arbitvp=ariadne.QRWin.viewports["Orth_viewport"]; arbitpl=arbitvp.ViewportPlane; tempLines = vtk.vtkPolyLine() tempLines.GetPointIds().SetNumberOfIds(2) tempLines.GetPointIds().SetId(0,0*3+0) tempLines.GetPointIds().SetId(1,0*3+1) for icell in range(arbitpl.ScaleBar.GetNumberOfCells()): arbitpl.ScaleBar.DeleteCell(icell); arbitpl.ScaleBar.RemoveDeletedCells(); arbitpl.ScaleBar.InsertNextCell(tempLines.GetCellType(),tempLines.GetPointIds()); ariadne.ChangeSynZoom(1); ariadne.SynchronizedZoom(0.034); ariadne.QRWin.Render(); ariadne.RegionAlpha.setValue(15); ariadne.SomaAlpha.setValue(40); ariadne.ckbx_HideBorder.setChecked(0) ariadne.ckbx_ShowYXScaleBar.setChecked(0) ariadne.ckbx_ShowYZScaleBar.setChecked(0) ariadne.ckbx_ShowZXScaleBar.setChecked(0) ariadne.ckbx_ShowArbitScaleBar.setChecked(1) ariadne.ckbx_HideBorder.setChecked(1) FPoint= (78233.9332778213, 61601.67070863842, 64849.07703562547) ; CamPos = (237350.73945325083, 80656.08301123015, -39741.523057454404) ; ViewUp= (0.12355078296512695, 0.9260262916142512, 0.3566658257639244) ; ariadne.SpinBox_ScaleBarWidth.setValue(2000) ariadne.radioBtn_tubesflat.setChecked(1) ariadne.SpinBox_Radius.setValue(150.0) ariadne.HideSkelNodes.setChecked(1) ariadne.ckbx_HideSomaLabels.setChecked(1) skelvp.Camera.SetViewUp(ViewUp) skelvp.Camera.SetFocalPoint(FPoint) skelvp.Camera.SetPosition(CamPos) skelvp.ResetCameraClippingRange(); vDir=np.array(ViewUp)*1.0; vtk.vtkMath.Normalize(vDir) cDir=np.array(FPoint)-np.array(CamPos); vtk.vtkMath.Normalize(cDir) arbitvp.ViewportPlane.JumpToPoint(np.array(FPoint),np.array(cDir),np.array(vDir)); skelvp.ResetCameraClippingRange(); ariadne.QRWin.Render();
def main(): colors = vtk.vtkNamedColors() # Create five points. origin = [0.0, 0.0, 0.0] p0 = [1.0, 0.0, 0.0] p1 = [0.0, 1.0, 0.0] p2 = [0.0, 1.0, 2.0] p3 = [1.0, 2.0, 3.0] # Create a vtkPoints object and store the points in it points = vtk.vtkPoints() points.InsertNextPoint(origin) points.InsertNextPoint(p0) points.InsertNextPoint(p1) points.InsertNextPoint(p2) points.InsertNextPoint(p3) polyLine = vtk.vtkPolyLine() polyLine.GetPointIds().SetNumberOfIds(5) for i in range(0, 5): polyLine.GetPointIds().SetId(i, i) # Create a cell array to store the lines in and add the lines to it cells = vtk.vtkCellArray() cells.InsertNextCell(polyLine) # Create a polydata to store everything in polyData = vtk.vtkPolyData() # Add the points to the dataset polyData.SetPoints(points) # Add the lines to the dataset polyData.SetLines(cells) # Setup actor and mapper mapper = vtk.vtkPolyDataMapper() mapper.SetInputData(polyData) actor = vtk.vtkActor() actor.SetMapper(mapper) actor.GetProperty().SetColor(colors.GetColor3d('Tomato')) # Setup render window, renderer, and interactor renderer = vtk.vtkRenderer() renderWindow = vtk.vtkRenderWindow() renderWindow.SetWindowName('PolyLine') renderWindow.AddRenderer(renderer) renderWindowInteractor = vtk.vtkRenderWindowInteractor() renderWindowInteractor.SetRenderWindow(renderWindow) renderer.AddActor(actor) renderer.SetBackground(colors.GetColor3d('DarkOliveGreen')) renderWindow.Render() renderWindowInteractor.Start()
def drawTrajectoryFoldVTK(self, qTrajectories, animate = False, trajectoryColor = [1.0,0.0,1.0]): self.trajectory = self.createTrajectory(qTrajectories[0], qTrajectories[1], N =20) for i in range(1,len(qTrajectories)-1): qi = qTrajectories[i] qe = qTrajectories[i+1] self.trajectory = numpy.concatenate((self.trajectory,self.createTrajectory(qi, qe, N =20))) Npoints, Nparams = self.trajectory.shape points = numpy.zeros((Npoints,3)) for i in range(Npoints): q = self.trajectory[i,:] self.moveRobot(q) points[i,:] = self.JointList[-1].Axis[0:3,3] pointsVTK = vtk.vtkPoints() polyLine = vtk.vtkPolyLine() polyLine.GetPointIds().SetNumberOfIds(Npoints) for i in range(Npoints): pointsVTK.InsertNextPoint(points[i,0],points[i,1],points[i,2]) polyLine.GetPointIds().SetId(i,i) cells = vtk.vtkCellArray() cells.InsertNextCell(polyLine) polyData = vtk.vtkPolyData() polyData.SetPoints(pointsVTK) polyData.SetLines(cells) mapper = vtk.vtkPolyDataMapper() mapper.SetInputData(polyData) trajectoryActor = vtk.vtkActor() trajectoryActor.SetMapper(mapper) trajectoryActor.GetProperty().SetColor(trajectoryColor[0],trajectoryColor[1],trajectoryColor[2]) # Init to first point q = self.trajectory[0,:] self.moveRobot(q) # Update robot segments and models self.JointList[-1].update() # Add trajectory to axis if animate: self.timer_count = 0 self.timer_countMax = Npoints self.timerBool = 1.0 self.drawVTK(drawAxis = True, actorsToAdd = [trajectoryActor], animate = animate)
def __init__(self, radius=1.0): """ Constructor @param radius earth's radius """ self.sf = shapefile.Reader('ne_10m_coastline') self.pts = [] self.lines = [] self.ugrids = [] self.appendFilter = vtk.vtkAppendFilter() for s in self.sf.shapes(): numPoints = len(s.points) # skip some smaller features if numPoints < 100: # skip continue vpts = vtk.vtkPoints() line = vtk.vtkPolyLine() ug = vtk.vtkUnstructuredGrid() vpts.SetNumberOfPoints(numPoints) ptIds = line.GetPointIds() ptIds.SetNumberOfIds(numPoints) index = 0 for p in s.points: lam, the = p[0] * np.pi / 180., p[1] * np.pi / 180. x = radius * np.cos(the) * np.cos(lam) y = radius * np.cos(the) * np.sin(lam) z = radius * np.sin(the) vpts.InsertPoint(index, x, y, z) ptIds.SetId(index, index) index += 1 # one cell ug.InsertNextCell(line.GetCellType(), ptIds) ug.SetPoints(vpts) # append to list to prevent Python from delete referenced objects self.pts.append(vpts) self.lines.append(line) self.ugrids.append(ug) self.appendFilter.AddInputData(ug) self.appendFilter.Update() self.ugrid = self.appendFilter.GetOutput()
def createLine(self, x1: float, y1: float, z1: float, x2: float, y2: float, z2: float, points: vtk.vtkPoints, cells: vtk.vtkCellArray): line = vtk.vtkPolyLine() line.GetPointIds().SetNumberOfIds(2) id_1 = points.InsertNextPoint(x1, y1, z1) # vtkIdType id_2 = points.InsertNextPoint(x2, y2, z2) # vtkIdType line.GetPointIds().SetId(0, id_1) line.GetPointIds().SetId(1, id_2) cells.InsertNextCell(line)
def ViewportBorder(renderer, color, last): # points start at upper right and proceed anti-clockwise points = vtk.vtkPoints() points.SetNumberOfPoints(4) points.InsertPoint(0, 1, 1, 0) points.InsertPoint(1, 0, 1, 0) points.InsertPoint(2, 0, 0, 0) points.InsertPoint(3, 1, 0, 0) # create cells, and lines cells = vtk.vtkCellArray() cells.Initialize() lines = vtk.vtkPolyLine() # only draw last line if this is the last viewport # this prevents double vertical lines at right border # if different colors are used for each border, then do # not specify last if (last): lines.GetPointIds().SetNumberOfIds(5) else: lines.GetPointIds().SetNumberOfIds(4) for i in range(0, 4): lines.GetPointIds().SetId(i, i) if (last): lines.GetPointIds().SetId(4, 0) cells.InsertNextCell(lines) # now make tge polydata and display it poly = vtk.vtkPolyData() poly.Initialize() poly.SetPoints(points) poly.SetLines(cells) # use normalized viewport coordinates since # they are independent of window size coordinate = vtk.vtkCoordinate() coordinate.SetCoordinateSystemToNormalizedViewport() mapper = vtk.vtkPolyDataMapper2D() mapper.SetInputData(poly) mapper.SetTransformCoordinate(coordinate) actor = vtk.vtkActor2D() actor.SetMapper(mapper) actor.GetProperty().SetColor(color) actor.GetProperty().SetLineWidth(2.0) renderer.AddViewProp(actor)
def _createTubePolyData(self, tube): '''Generates polydata from an itk.VesselTubeSpatialObject.''' points = GetTubePoints(tube) # Convert points to world space. tube.ComputeObjectToWorldTransform() transform = tube.GetIndexToWorldTransform() # Get scaling vector from transform matrix diagonal. scaling = [transform.GetMatrix()(i, i) for i in range(3)] # Use average of scaling vector for scale since TubeFilter # doesn't seem to support ellipsoid. scale = sum(scaling) / len(scaling) for i in range(len(points)): pt, radius = points[i] pt = transform.TransformPoint(pt) points[i] = (pt, radius * scale) vpoints = vtk.vtkPoints() vpoints.SetNumberOfPoints(len(points)) scalars = vtk.vtkFloatArray() scalars.SetNumberOfValues(len(points)) scalars.SetName('Radii') minRadius = float('inf') maxRadius = float('-inf') for i, (pt, r) in enumerate(points): vpoints.SetPoint(i, pt) scalars.SetValue(i, r) minRadius = min(r, minRadius) maxRadius = max(r, maxRadius) pl = vtk.vtkPolyLine() pl.Initialize(len(points), range(len(points)), vpoints) ca = vtk.vtkCellArray() ca.InsertNextCell(pl) pd = vtk.vtkPolyData() pd.SetLines(ca) pd.SetPoints(vpoints) pd.GetPointData().SetScalars(scalars) pd.GetPointData().SetActiveScalars('Radii') tf = vtk.vtkTubeFilter() tf.SetInputData(pd) tf.SetVaryRadiusToVaryRadiusByAbsoluteScalar() tf.SetRadius(minRadius) tf.SetRadiusFactor(maxRadius / minRadius) tf.SetNumberOfSides(20) tf.Update() return tf.GetOutput()
def write_vtk(self, data_dir='./data', file_name='spines.vtk', binary=False): """ Write the spines into a vtk file. call signature: write_vtk(data_dir='./data', file_name='spines.vtk', binary=False) Arguments: *data_dir*: Target data directory. *file_name*: Target file name. *binary*: Write file in binary or ASCII format. """ writer = vtk.vtkPolyDataWriter() if binary: writer.SetFileTypeToBinary() else: writer.SetFileTypeToASCII() writer.SetFileName(os.path.join(data_dir, file_name)) poly_data = vtk.vtkPolyData() points = vtk.vtkPoints() # Create the cell to store the lines in. cells = vtk.vtkCellArray() poly_lines = [] offset = 0 for line_idx in range(len(self.spines)): n_points = self.spines[line_idx].shape[0] poly_lines.append(vtk.vtkPolyLine()) poly_lines[-1].GetPointIds().SetNumberOfIds(n_points) for point_idx in range(n_points): points.InsertNextPoint(self.spines[line_idx][point_idx]) poly_lines[-1].GetPointIds().SetId(point_idx, point_idx + offset) cells.InsertNextCell(poly_lines[-1]) offset += n_points poly_data.SetPoints(points) poly_data.SetLines(cells) # Insure compatability between vtk 5 and 6. try: writer.SetInputData(poly_data) except: writer.SetInput(poly_data) writer.Write()
def makeVTKWells(fname_base, welltracks_df, xml=False): """Creates a vtk Unstructured Grid file (*.vtk, *.vtu) from a welltracks DataFrame Parameters: fname_base -- the output filename will be [fname_base].vtk or [fname_base].vtu for xml format welltracks_df -- DataFrame contaning 'X', 'Y', and 'Elev_mASL' columns. This is created using the transformCoords function. xml -- set to True if xml format is preferred """ numpoints = welltracks_df.shape[0] wells = welltracks_df['Well'].unique().tolist() numwells = len(wells) grid = vtkUnstructuredGrid() points = vtkPoints() for i in range(numpoints): points.InsertNextPoint(welltracks_df.loc[i,'X'], welltracks_df.loc[i,'Y'], welltracks_df.loc[i,'Z']) cells = vtkCellArray() wellname = vtkStringArray() wellname.SetName('Well') for well in wells: print well polyline = vtkPolyLine() indices = welltracks_df[welltracks_df['Well']==well].index.tolist() for i, j in enumerate(indices): polyline.GetPointIds().SetNumberOfIds(len(indices)) polyline.GetPointIds().SetId(i,j) cells.InsertNextCell(polyline) wellname.InsertNextValue(well) grid.SetPoints(points) grid.SetCells(VTK_POLY_LINE, cells) grid.GetCellData().AddArray(wellname) if xml: writer = vtkXMLUnstructuredGridWriter() writer.SetFileName('{}.vtu'.format(fname_base)) writer.SetDataModeToAscii() writer.SetInputData(grid) writer.Write() else: writer = vtkUnstructuredGridWriter() writer.SetFileName('{}.vtk'.format(fname_base)) writer.SetInputData(grid) writer.Write()
def create_actor_mesh(pts, lines, color, **kwargs): """ Creates a VTK actor for rendering quadrilateral plots. :param pts: points :type pts: vtkFloatArray :param lines: point connectivity information :type lines: vtkIntArray :param color: actor color :type color: list :return: a VTK actor :rtype: vtkActor """ # Keyword arguments array_name = kwargs.get('name', "") array_index = kwargs.get('index', 0) line_width = kwargs.get('size', 0.5) # Create points points = vtk.vtkPoints() points.SetData(pts) # Create lines cells = vtk.vtkCellArray() for line in lines: pline = vtk.vtkPolyLine() pline.GetPointIds().SetNumberOfIds(5) for i in range(len(line)): pline.GetPointIds().SetId(i, line[i]) pline.GetPointIds().SetId(4, line[0]) cells.InsertNextCell(pline) # Create a PolyData object and add points & lines polydata = vtk.vtkPolyData() polydata.SetPoints(points) polydata.SetLines(cells) # Map poly data to the graphics primitives mapper = vtk.vtkPolyDataMapper() mapper.SetInputDataObject(polydata) mapper.SetArrayName(array_name) mapper.SetArrayId(array_index) # Create an actor and set its properties actor = vtk.vtkActor() actor.SetMapper(mapper) actor.GetProperty().SetColor(*color) actor.GetProperty().SetLineWidth(line_width) # Return the actor return actor
def prepContinents(fnm): """ This converts vcs continents files to vtkpolydata Author: Charles Doutriaux Input: vcs continent file name """ if vcsContinents.has_key(fnm): return vcsContinents[fnm] poly =vtk.vtkPolyData() cells = vtk.vtkCellArray() pts = vtk.vtkPoints() f=open(fnm) ln=f.readline() while ln.strip().split()!=["-99","-99"]: # Many lines, need to know number of points N = int(ln.split()[0]) # Now create and store these points n=0 npts = pts.GetNumberOfPoints() while n<N: ln=f.readline() sp=ln.split() sn = len(sp) didIt = False if sn%2 == 0: try: spts = [] for i in range(sn/2): l,L = float(sp[i*2]),float(sp[i*2+1]) spts.append([l,L]) for p in spts: pts.InsertNextPoint(p[1],p[0],0.) n+=sn didIt = True except: didIt = False if didIt is False: while len(ln)>2: l,L=float(ln[:8]),float(ln[8:16]) pts.InsertNextPoint(L,l,0.) ln=ln[16:] n+=2 ln = vtk.vtkPolyLine() ln.GetPointIds().SetNumberOfIds(N/2) for i in range(N/2): ln.GetPointIds().SetId(i,i+npts) cells.InsertNextCell(ln) ln=f.readline() poly.SetPoints(pts) poly.SetLines(cells) vcsContinents[fnm]=poly return poly
def createPolyLine(points): pd = createPolyData(points) # Create cells cell = vtk.vtkPolyLine() cell.GetPointIds().SetNumberOfIds(pd.GetNumberOfPoints()) for i in range(pd.GetNumberOfPoints()): cell.GetPointIds().SetId(i, i) cells = vtk.vtkCellArray() cells.InsertNextCell(cell) pd.SetLines(cells) return pd
def prepContinents(fnm): """ This converts vcs continents files to vtkpolydata Author: Charles Doutriaux Input: vcs continent file name """ poly = vtk.vtkPolyData() cells = vtk.vtkCellArray() pts = vtk.vtkPoints() f = open(fnm) ln = f.readline() while ln.strip().split() != ["-99", "-99"]: # Many lines, need to know number of points N = int(ln.split()[0]) # Now create and store these points n = 0 npts = pts.GetNumberOfPoints() while n < N: ln = f.readline() sp = ln.split() sn = len(sp) didIt = False if sn % 2 == 0: try: spts = [] for i in range(sn / 2): l, L = float(sp[i * 2]), float(sp[i * 2 + 1]) spts.append([l, L]) for p in spts: pts.InsertNextPoint(p[1], p[0], 0.0001) n += sn didIt = True except: didIt = False if didIt is False: while len(ln) > 2: l, L = float(ln[:8]), float(ln[8:16]) pts.InsertNextPoint(L, l, 0.0001) ln = ln[16:] n += 2 ln = vtk.vtkPolyLine() ln.GetPointIds().SetNumberOfIds(N / 2) for i in range(N / 2): ln.GetPointIds().SetId(i, i + npts) cells.InsertNextCell(ln) ln = f.readline() poly.SetPoints(pts) poly.SetLines(cells) return poly
def UpdateTimeIndex( self, time_index ): (edgelist, verts, fibers) = read_fibers( time_index ); self.polylinePoints.SetNumberOfPoints( verts.size ) for i,X in enumerate(verts): self.polylinePoints.InsertPoint(i, X[0], X[1], X[2] ) self.cells.Reset() for f in fibers: self.polyline = vtk.vtkPolyLine() self.polyline.GetPointIds().SetNumberOfIds( len(f) ) for i,v in enumerate(f): self.polyline.GetPointIds().SetId( i, v ) self.cells.InsertNextCell( self.polyline ) self.polydata.Modified()
def genPoly(coords, pts, filled=True): N = pts.GetNumberOfPoints() if filled: poly = vtk.vtkPolygon() else: poly = vtk.vtkPolyLine() pid = poly.GetPointIds() n = len(coords) pid.SetNumberOfIds(n) for j in range(n): c = list(coords[j]) if len(c) == 2: c.append(0) pts.InsertNextPoint(*c) pid.SetId(j, j + N) return poly
def addPolyLineToDataSet(polyData, points): origNumPts = polyData.GetNumberOfPoints() # Verify that the polyDataSet has a point array if origNumPts == 0: polyData.SetPoints(vtk.vtkPoints()) polyData.SetLines(vtk.vtkCellArray()) cell = vtk.vtkPolyLine() cell.GetPointIds().SetNumberOfIds(points.shape[0]) for i, pt in enumerate(points): # Insert point polyData.GetPoints().InsertNextPoint(pt[0], pt[1], pt[2]) # Associate point id to line cell.GetPointIds().SetId(i, origNumPts + i) lines = polyData.GetLines().InsertNextCell(cell)
def genPoly(coords,pts,filled=True): N = pts.GetNumberOfPoints() if filled: poly = vtk.vtkPolygon() else: poly = vtk.vtkPolyLine() pid = poly.GetPointIds() n = len(coords) pid.SetNumberOfIds(n) for j in range(n): c = list(coords[j]) if len(c)==2: c.append(0) pts.InsertNextPoint(*c) pid.SetId(j,j+N) return poly
def _Execute(self, *args): """Do the work. Do not call this method in user code, it will be called by the VTK executive. """ # Clear out any old centreline data self.Centerline.PrepareForNewData() nSegments = self._GetNz() h = self.GetHeight() dz = self._GetDz() c = self.GetCenter() n = self.GetDirection() # These points define the line points = vtk.vtkPoints() # nSeg + 1 fence posts for nSeg sections of fence points.SetNumberOfPoints(nSegments + 1) # This will hold the ids of points in 'points' line = vtk.vtkPolyLine() line.GetPointIds().SetNumberOfIds(nSegments + 1) # Set the coordinates along the line and the ids for i in range(nSegments + 1): # Points start at -h/2 along the axis and advance in steps of dz # along the direction (n, a unit vector) x = c + (i*dz - 0.5*h) * n points.SetPoint(i, x[0], x[1], x[2]) line.GetPointIds().SetId(i, i) continue # Create the vtkPolyData self.Centerline.Allocate(1,1) self.Centerline.SetPoints(points) self.Centerline.InsertNextCell(line.GetCellType(), line.GetPointIds()) # Pass it into the vtkTubeFilter self.Tuber.SetInputData(self.Centerline) # Get the output self.Triangulator.Update() # Copy to our output out = self.GetPolyDataOutput() out.ShallowCopy(self.Triangulator.GetOutput()) return
def __init__(self, lambdaFunction, thetaFunction, nt=11, radius=1.0): """ Create a polyline @param lambdaFunction lambda (longitude) function of t (0 <= t <= 1) @param thetaFunction theta (latitude) functuon of t (0 <= t <= 1) """ self.ptData = vtk.vtkDoubleArray() self.pts = vtk.vtkPoints() self.line = vtk.vtkPolyLine() self.grid = vtk.vtkUnstructuredGrid() self.poly = vtk.vtkPolyData() self.cells = vtk.vtkCellArray() ts = numpy.linspace(0., 1., nt) lams = lambdaFunction(ts) thes = thetaFunction(ts) xs = radius * numpy.cos(thes) * numpy.cos(lams) ys = radius * numpy.cos(thes) * numpy.sin(lams) zs = radius * numpy.sin(thes) self.xyz = numpy.zeros((nt, 3), numpy.float64) self.xyz[:, 0] = xs self.xyz[:, 1] = ys self.xyz[:, 2] = zs self.ptData.SetNumberOfComponents(3) self.ptData.SetNumberOfTuples(nt) self.ptData.SetVoidArray(self.xyz, nt * 3, 1) self.pts.SetNumberOfPoints(nt) self.pts.SetData(self.ptData) ptIds = self.line.GetPointIds() ptIds.SetNumberOfIds(nt) for i in range(ptIds.GetNumberOfIds()): ptIds.SetId(i, i) self.grid.SetPoints(self.pts) self.grid.Allocate(1, 1) # one cell self.grid.InsertNextCell(self.line.GetCellType(), ptIds) self.cells.InsertNextCell(self.line) self.poly.SetPoints(self.pts) self.poly.SetLines(self.cells)
def generate_plane_path(): """ Generate the plane path :return: the actor of the plane path """ size, coordinates = read_txt(VTK_PLANE_GPS) plane_points = vtk.vtkPoints() plane_lines = vtk.vtkPolyLine() plane_lines.GetPointIds().SetNumberOfIds(int(size)) scalar = vtk.vtkFloatArray() previous_alt = coordinates[0][2] for i, (x, y, alt) in enumerate(coordinates): lat, long = convert_rt90_to_gps_coordinate(x, y) plane_points.InsertNextPoint(coordinate_earth(lat, long, alt)) plane_lines.GetPointIds().SetId(i, i) delta_alt = previous_alt - alt scalar.InsertNextValue(delta_alt) previous_alt = alt min_scalar, max_scalar = scalar.GetValueRange() plane_cells = vtk.vtkCellArray() plane_cells.InsertNextCell(plane_lines) plane_data = vtk.vtkPolyData() plane_data.SetPoints(plane_points) plane_data.SetLines(plane_cells) plane_data.GetPointData().SetScalars(scalar) plane_tube = vtk.vtkTubeFilter() plane_tube.SetRadius(35) plane_tube.SetInputData(plane_data) plane_mapper = vtk.vtkPolyDataMapper() plane_mapper.SetInputConnection(plane_tube.GetOutputPort()) plane_mapper.SetScalarRange(min_scalar, max_scalar) plane_actor = vtk.vtkActor() plane_actor.SetMapper(plane_mapper) return plane_actor
def create_line(self, pos, color): _points = pos _color = color _line = vtk.vtkPolyLine() # we have _points _total_points_in_track = len(_points) _line.GetPointIds().SetNumberOfIds(_total_points_in_track) # set color to line self.colors.SetNumberOfComponents(4) for index, p in enumerate(_points): self.points.InsertNextPoint(p) _line.GetPointIds().SetId(index, self.points.GetNumberOfPoints() - 1) self.colors.InsertNextTuple(_color) self.lines_cells.InsertNextCell(_line)
def as_polyline(points, level): """ Koch Snowflake as a vtkPolyLine """ # Use the points from the previous iteration to create the points of the next # level. There is an assumption on my part that the curve is traversed in a # counterclockwise fashion. If the initial triangle above is written to # describe clockwise motion, the points will face inward instead of outward. for i in range(level): temp = vtk.vtkPoints() # The first point of the previous vtkPoints is the first point of the next vtkPoints. temp.InsertNextPoint(*points.GetPoint(0)) # Iterate over "edges" in the vtkPoints for i in range(1, points.GetNumberOfPoints()): x0, y0, z0 = points.GetPoint(i - 1) x1, y1, z1 = points.GetPoint(i) t = sqrt((x1 - x0)**2 + (y1 - y0)**2) nx = (x1 - x0) / t # x-component of edge unit tangent ny = (y1 - y0) / t # y-component of edge unit tangent # the points describing the Koch snowflake edge temp.InsertNextPoint(x0 + nx * t / 3, y0 + ny * t / 3, 0.) temp.InsertNextPoint(x0 + nx * t / 2 + ny * t * sqrt(3) / 6, y0 + ny * t / 2 - nx * t * sqrt(3) / 6, 0.) temp.InsertNextPoint(x0 + nx * 2 * t / 3, y0 + ny * 2 * t / 3, 0.) temp.InsertNextPoint(x0 + nx * t, y0 + ny * t, 0.) points = temp # draw the outline lines = vtk.vtkCellArray() pl = vtk.vtkPolyLine() pl.GetPointIds().SetNumberOfIds(points.GetNumberOfPoints()) for i in range(points.GetNumberOfPoints()): pl.GetPointIds().SetId(i, i) lines.InsertNextCell(pl) # complete the polydata polydata = vtk.vtkPolyData() polydata.SetLines(lines) polydata.SetPoints(points) return polydata
def _Execute(self, *args): """Do the work. Do not call this method in user code, it will be called by the VTK executive. """ # Clear out any old centreline data self.Centerline.PrepareForNewData() nSegments = self._GetNz() h = self.GetHeight() dz = self._GetDz() c = self.GetCenter() n = self.GetDirection() # These points define the line points = vtk.vtkPoints() # nSeg + 1 fence posts for nSeg sections of fence points.SetNumberOfPoints(nSegments + 1) # This will hold the ids of points in 'points' line = vtk.vtkPolyLine() line.GetPointIds().SetNumberOfIds(nSegments + 1) # Set the coordinates along the line and the ids for i in range(nSegments + 1): # Points start at -h/2 along the axis and advance in steps of dz # along the direction (n, a unit vector) x = c + (i * dz - 0.5 * h) * n points.SetPoint(i, x[0], x[1], x[2]) line.GetPointIds().SetId(i, i) continue # Create the vtkPolyData self.Centerline.Allocate(1, 1) self.Centerline.SetPoints(points) self.Centerline.InsertNextCell(line.GetCellType(), line.GetPointIds()) # Pass it into the vtkTubeFilter self.Tuber.SetInputData(self.Centerline) # Get the output self.Triangulator.Update() # Copy to our output out = self.GetPolyDataOutput() out.ShallowCopy(self.Triangulator.GetOutput()) return
def makeVTKWellsUsingModule(fname_base, welltracks_df, xml=False): numpoints = welltracks_df.shape[0] wells = welltracks_df['Well'].unique().tolist() numwells = len(wells) grid = vtkUnstructuredGrid() points = vtkPoints() for i in range(numpoints): points.InsertNextPoint(welltracks_df.loc[i,'X'], welltracks_df.loc[i,'Y'], welltracks_df.loc[i,'Elev_mASL']) cells = vtkCellArray() wellname = vtkStringArray() wellname.SetName('Well') for well in wells: print well polyline = vtkPolyLine() indices = welltracks_df[welltracks_df['Well']==well].index.tolist() for i, j in enumerate(indices): polyline.GetPointIds().SetNumberOfIds(len(indices)) polyline.GetPointIds().SetId(i,j) cells.InsertNextCell(polyline) wellname.InsertNextValue(well) grid.SetPoints(points) grid.SetCells(VTK_POLY_LINE, cells) grid.GetCellData().AddArray(wellname) if xml: writer = vtkXMLUnstructuredGridWriter() writer.SetFileName('{}.vtu'.format(fname_base)) writer.SetDataModeToAscii() writer.SetInputData(grid) writer.Write() else: writer = vtkUnstructuredGridWriter() writer.SetFileName('{}.vtk'.format(fname_base)) writer.SetInputData(grid) writer.Write()
def createLineVTKData(pts, col): points = vtk.vtkPoints() for p in pts: points.InsertNextPoint(p) lines = vtk.vtkCellArray() pl = vtk.vtkPolyLine() pl.GetPointIds().SetNumberOfIds(points.GetNumberOfPoints()) for i in range(points.GetNumberOfPoints()): pl.GetPointIds().SetId(i, i) lines.InsertNextCell(pl) polydata = vtk.vtkPolyData() polydata.SetLines(lines) polydata.SetPoints(points) colors = vtk.vtkUnsignedCharArray() colors.SetNumberOfComponents(3) colors.SetName("Colors") colors.InsertNextTupleValue(col) polydata.GetCellData().SetScalars(colors) return polydata
def UpdateData( time_index ): print time_index textActor.SetInput( "Dynamics Test:" + str(time_index) ) (edgelist, verts, fibers) = read_fibers( time_index ); polylinePoints.SetNumberOfPoints( verts.size ) for i,X in enumerate(verts): polylinePoints.InsertPoint(i, X[0], X[1], X[2] ) cells.SetNumberOfCells(0) for f in fibers: polyline = vtk.vtkPolyLine() polyline.GetPointIds().SetNumberOfIds( len(f) ) for i,v in enumerate(f): polyline.GetPointIds().SetId( i, v ) cells.InsertNextCell( polyline ) polydata.Modified()
def as_polyline(points, level): # Use the points from the previous iteration to create the points of the next # level. There is an assumption on my part that the curve is traversed in a # counterclockwise fashion. If the initial triangle above is written to # describe clockwise motion, the points will face inward instead of outward. for i in range(level): temp = vtk.vtkPoints() # The first point of the previous vtkPoints is the first point of the next vtkPoints. temp.InsertNextPoint(*points.GetPoint(0)) # Iterate over "edges" in the vtkPoints for i in range(1, points.GetNumberOfPoints()): x0, y0, z0 = points.GetPoint(i - 1) x1, y1, z1 = points.GetPoint(i) t = sqrt((x1 - x0)**2 + (y1 - y0)**2) nx = (x1 - x0)/t # x-component of edge unit tangent ny = (y1 - y0)/t # y-component of edge unit tangent # the points describing the Koch snowflake edge temp.InsertNextPoint(x0 + nx*t/3, y0 + ny*t/3, 0.) temp.InsertNextPoint(x0 + nx*t/2 + ny*t*sqrt(3)/6, y0 + ny*t/2 - nx*t*sqrt(3)/6, 0.) temp.InsertNextPoint(x0 + nx*2*t/3, y0 + ny*2*t/3, 0.) temp.InsertNextPoint(x0 + nx*t, y0 + ny*t, 0.) points = temp # draw the outline lines = vtk.vtkCellArray() pl = vtk.vtkPolyLine() pl.GetPointIds().SetNumberOfIds(points.GetNumberOfPoints()) for i in range(points.GetNumberOfPoints()): pl.GetPointIds().SetId(i, i) lines.InsertNextCell(pl) # complete the polydata polydata = vtk.vtkPolyData() polydata.SetLines(lines) polydata.SetPoints(points) return polydata
def CreateVersor(o, r, color=[0, 0, 0]): """ Ritorna una lista di attori contenetni un versore o = origine r= versore """ points = [] Lines=[] Polygon = vtk.vtkPolyData() ac=[] points = vtk.vtkPoints() points.SetNumberOfPoints(2) r = normalize(r) points.SetPoint(0, o) points.SetPoint(1, [o[0]+r[0], o[1]+r[1], o[2]+r[2]]) polyLine0 = vtk.vtkPolyLine() polyLine0.GetPointIds().SetNumberOfIds(2) polyLine0.GetPointIds().SetId(0,0) polyLine0.GetPointIds().SetId(1,1) cells0 = vtk.vtkCellArray() cells0.InsertNextCell(polyLine0) polyData = vtk.vtkPolyData() polyData.SetPoints(points) polyData.SetLines(cells0) ac=[] ac.append(CreateSphere(points.GetPoint(0), 0.05, [1, 1, 1])) ac.append(CreateSphere(points.GetPoint(1), 0.1, color)) ac.append(CreateActor(polyData)) return ac
def make_polyline(def_tup): global sorted_residues (start_res, end_res) = def_tup # print "start res", start_res, "end res", end_res # print "Looking for helix, from >%s< -> >%s<" % (start_res, end_res) # print "\n".join(map(lambda r: ">"+r[0]+"<", sorted_residues)) #"len sorted reses: ", len(sorted_residues) (start_idx, end_idx) = residue_index(start_res, end_res) assert -1 < start_idx and -1 < end_idx, "strt: %s, end %s" % (start_res, end_res) # +1 as we want /inclusive/ # print "start idx", start_idx, "end", end_idx residues = sorted_residues[start_idx : end_idx + 1] polyLinePoints = vtk.vtkPoints() polyLinePoints.SetNumberOfPoints(len(residues)) aPolyLine = vtk.vtkPolyLine() aPolyLine.GetPointIds().SetNumberOfIds(len(residues)) for i,r in enumerate(residues): (x, y, z) = r[1] # print "pt: ", x, y, z polyLinePoints.InsertPoint(i, x, y, z) aPolyLine.GetPointIds().SetId(i, i) return (polyLinePoints, aPolyLine)
def load(self, srcfn): sfh = file(srcfn, 'r') if None == sfh: raise Exception, "Failed to open file - %s." % (srcfn) try: curline = "#" LNo = 0 while curline: curline = sfh.readline() LNo += 1 curline = curline.lstrip().rstrip('\r\n') if len(split(curline)) == 1 and curline not in ["#","//","/*","%"]: break lnTotal = int(curline) lnCnt = 0 ptCnt = 0 while curline and lnCnt < lnTotal: # read line by line, in order to avoid the memory swelling by otherwise loading all lines once curline = sfh.readline() LNo += 1 curline = curline.lstrip().rstrip('\r\n') if len(curline) < 1 or curline in ["#","//","/*","%"]: continue vtTotal = int(curline) vtCnt = 0 startPtId = ptCnt while curline and vtCnt < vtTotal: curline = sfh.readline() LNo += 1 curline = curline.lstrip().rstrip('\r\n') if len(curline) < 1 or curline in ["#","//","/*","%"]: continue # alway splitting a line with whitespace as the delimiter words = split(curline) if len(words) < 6: # not a vertex line continue self.allPoints.InsertNextPoint( float(words[0]), float(words[1]), float(words[2]) ) ptCnt += 1 vtCnt += 1 if vtCnt < vtTotal : raise IOError, "Insufficient points on line No.%d, at file Line %d, aborted.\n" % (lnCnt, LNo) vtkln = vtk.vtkPolyLine() vtkln.GetPointIds().SetNumberOfIds(vtTotal) for id in range(0, vtTotal): vtkln.GetPointIds().SetId( id, id + startPtId ) self.allLines.InsertNextCell( vtkln ) lnCnt += 1 if lnCnt < lnTotal: raise IOError, "Error encountered at file Line %d - Insufficient lines.\n" % (LNo) self.SetPoints( self.allPoints ) self.SetLines ( self.allLines ) self.fndata = srcfn finally: sfh.close()
aLineGrid.Allocate(1,1) aLineGrid.InsertNextCell(aLine.GetCellType(),aLine.GetPointIds()) aLineGrid.SetPoints(linePoints) aLineMapper = vtk.vtkDataSetMapper() aLineMapper.SetInputData(aLineGrid) aLineActor = vtk.vtkActor() aLineActor.SetMapper(aLineMapper) aLineActor.AddPosition(0,0,4) aLineActor.GetProperty().BackfaceCullingOn() # Polyline polyLinePoints = vtk.vtkPoints() polyLinePoints.SetNumberOfPoints(3) polyLinePoints.InsertPoint(0,0,0,0) polyLinePoints.InsertPoint(1,1,1,0) polyLinePoints.InsertPoint(2,1,0,0) aPolyLine = vtk.vtkPolyLine() aPolyLine.GetPointIds().SetNumberOfIds(3) aPolyLine.GetPointIds().SetId(0,0) aPolyLine.GetPointIds().SetId(1,1) aPolyLine.GetPointIds().SetId(2,2) aPolyLineGrid = vtk.vtkUnstructuredGrid() aPolyLineGrid.Allocate(1,1) aPolyLineGrid.InsertNextCell(aPolyLine.GetCellType(),aPolyLine.GetPointIds()) aPolyLineGrid.SetPoints(polyLinePoints) aPolyLineMapper = vtk.vtkDataSetMapper() aPolyLineMapper.SetInputData(aPolyLineGrid) aPolyLineActor = vtk.vtkActor() aPolyLineActor.SetMapper(aPolyLineMapper) aPolyLineActor.AddPosition(2,0,4) aPolyLineActor.GetProperty().BackfaceCullingOn() # Vertex
def display_tube(self,gfx,caller): if gfx.ps != None: gfx.renderer.RemoveActor(gfx.ps.acteur) if self.c!='' and self.T!='' and self.U!='' and self.henttype=='cTU':#CTU CASE ptype='delta' self.enttype='cTU' deltaz = (self.c/self.U) deltaphi = (self.T * 360.0)/self.U self.dphi = deltaphi self.dz = deltaz elif self.dphi!='' and self.dz!='' and self.henttype=='Elm-Hel':#DELTA CASE ptype = 'delta' self.enttype='Elm-Hel' deltaphi = self.dphi deltaz =self.dz else : MB.showwarning('Info','Configure symmetry setting') return try: zmax = gfx.map[0].box.GetBounds()[5] zmin = gfx.map[0].box.GetBounds()[4] z = zmax - zmin except: z= 4*360*abs(self.dz/self.dphi) #ici exeption 'fit' calcule de dz avec ratio !!! if 'fit' in caller: self.c = self.c * gfx.map[0].ratio self.dz = self.dz * gfx.map[0].ratio deltaz =self.dz numPts = int(z/deltaz) self.numpts = numPts#definition du nombre de sm self.cptsymops_tube(ptype,numPts) #ptype est tjs = a delta on calcule toujours de la même maniere dans symmetry #parameter definition : shifta = radians(deltaphi) phizero = radians(self.phizero) ###definition des boules selon les parametres pdo = vtk.vtkPolyData() newPts = vtk.vtkPoints() #This will store the points for the Helix vals = vtk.vtkDoubleArray() for i in range(0, numPts): try : x = self.radius * gfx.map[0].scale * cos(i*shifta + phizero) y = self.radius * gfx.map[0].scale * sin(i*shifta + phizero) z = zmin + i*deltaz except : x = self.radius * cos(i*shifta + phizero) y = self.radius * sin(i*shifta + phizero) z = i*deltaz newPts.InsertPoint(i, x,y,z) vals.InsertNextValue(i) pdo.SetPoints(newPts) pdo.GetPointData().SetScalars(vals) sphere = vtk.vtkSphereSource() sphere.SetCenter(0, 0, 0) try : sphere.SetRadius(self.radius*gfx.map[0].scale/5.0) except: sphere.SetRadius(self.radius*(1/5.)) sphere.SetThetaResolution(8) sphere.SetStartTheta(0) sphere.SetEndTheta(360) sphere.SetPhiResolution(8) sphere.SetStartPhi(0) sphere.SetEndPhi(180) glyph = vtk.vtkGlyph3D() glyph.SetInput(pdo) glyph.SetColorMode(1) glyph.ScalingOn() glyph.SetScaleMode(2) glyph.SetScaleFactor(0.25) glyph.SetSource(sphere.GetOutput()) self.spheremapper = vtk.vtkPolyDataMapper() self.spheremapper.SetInputConnection(glyph.GetOutputPort()) self.spheremapper.UseLookupTableScalarRangeOff() self.spheremapper.SetScalarVisibility(0) self.sphact = vtk.vtkActor() self.sphact.PickableOff() self.sphact.DragableOff() self.sphact.SetMapper(self.spheremapper) self.sphact.GetProperty().SetRepresentationToSurface() self.sphact.GetProperty().SetInterpolationToGouraud() self.sphact.GetProperty().SetAmbient(0.15) self.sphact.GetProperty().SetDiffuse(0.85) self.sphact.GetProperty().SetSpecular(0.1) self.sphact.GetProperty().SetSpecularPower(100) self.sphact.GetProperty().SetSpecularColor(1, 1, 1) self.sphact.GetProperty().SetColor(1,1,1) ###definition de l helice continue enhance=100 hlxpdo = vtk.vtkPolyData() hlxnewPts = vtk.vtkPoints() #This will store the points for the Helix hlxvals = vtk.vtkDoubleArray() hlxnumPts = int(numPts*enhance) for i in range(0, hlxnumPts): try : x = self.radius * gfx.map[0].scale * cos(i*shifta/enhance + phizero) y = self.radius * gfx.map[0].scale * sin(i*shifta/enhance + phizero) z = zmin + i*deltaz/enhance except : x = self.radius * cos(i*shifta/enhance + phizero) y = self.radius * sin(i*shifta/enhance + phizero) z = i*deltaz/enhance hlxnewPts.InsertPoint(i, x,y,z) hlxvals.InsertNextValue(i) hlxpdo.SetPoints(hlxnewPts) hlxpdo.GetPointData().SetScalars(hlxvals) aPolyLine = vtk.vtkPolyLine() aPolyLine.GetPointIds().SetNumberOfIds(hlxnumPts) for i in range(0,hlxnumPts): aPolyLine.GetPointIds().SetId(i, i) hlxpdo.Allocate(1, 1) hlxpdo.InsertNextCell(aPolyLine.GetCellType(), aPolyLine.GetPointIds()) self.mapper = vtk.vtkPolyDataMapper() self.mapper.SetScalarVisibility(0) self.mapper.SetInput(hlxpdo) self.helact = vtk.vtkActor() self.helact.PickableOff() self.helact.DragableOff() self.helact.GetProperty().SetColor(1,1,1) self.helact.GetProperty().SetRepresentationToWireframe() self.helact.GetProperty().SetLineWidth(5) self.helact.GetProperty().SetLineWidth(1) self.helact.GetProperty().SetSpecular(.4) self.helact.GetProperty().SetSpecularPower(10) self.helact.SetMapper(self.mapper) assembly = vtk.vtkAssembly() assembly.AddPart(self.sphact) assembly.AddPart(self.helact) helcol = [(1,1,1),(1,0,0.3),(0.3,0,1),(0,1,0.3)] for i in range(1,self.s+1): if i == 1: continue else : tmp_sphact= vtk.vtkActor() tmp_helact= vtk.vtkActor() tmp_sphact.ShallowCopy(self.sphact) tmp_helact.ShallowCopy(self.helact) ps=vtk.vtkProperty() ph=vtk.vtkProperty() ps.SetColor(helcol[(i-1)%4]) ph.SetColor(helcol[(i-1)%4]) tmp_sphact.SetProperty(ps) tmp_helact.SetProperty(ph) tmp_sphact.RotateWXYZ((360/self.s)*(i-1),0,0,1) tmp_helact.RotateWXYZ((360/self.s)*(i-1),0,0,1) assembly.AddPart(tmp_sphact) assembly.AddPart(tmp_helact) self.acteur=assembly gfx.renderer.AddActor(self.acteur) gfx.renwin.Render() gfx.ps = self return ptype
def display_Xn(self,gfx): if gfx.ps != None: gfx.renderer.RemoveActor(gfx.ps.acteur) try: zmax = gfx.map[0].box.GetBounds()[5] zmin = gfx.map[0].box.GetBounds()[4] ymax = gfx.map[0].box.GetBounds()[3] ymin = gfx.map[0].box.GetBounds()[2] c = (zmax - zmin)/2. b = (ymax - ymin)/2. except: b = c = self.radius dist = self.radius phizero = radians(self.phizero) if self.solidtype=='Cn': numPts = self.cnn shifta = radians(360./numPts) pdo = vtk.vtkPolyData() cirpdo = vtk.vtkPolyData() newPts = vtk.vtkPoints() vals = vtk.vtkDoubleArray() for i in range(0, numPts): try : if self.axe=='Z': x = dist * gfx.map[0].scale * cos(i*shifta + phizero) y = dist * gfx.map[0].scale * sin(i*shifta + phizero) z = 0 elif self.axe == 'Y': x = dist * gfx.map[0].scale * cos(i*shifta + phizero) y = 0 z = dist * gfx.map[0].scale * sin(i*shifta + phizero) elif self.axe == 'X': x = 0 y = dist * gfx.map[0].scale * cos(i*shifta + phizero) z = dist * gfx.map[0].scale * sin(i*shifta + phizero) except : if self.axe=='Z': x = dist * cos(i*shifta + phizero) y = dist * sin(i*shifta + phizero) z = 0 elif self.axe == 'Y': x = dist * cos(i*shifta + phizero) y = 0 z = dist * sin(i*shifta + phizero) elif self.axe == 'X': x = 0 y = dist * cos(i*shifta + phizero) z = dist * sin(i*shifta + phizero) newPts.InsertPoint(i, x,y,z) vals.InsertNextValue(i) pdo.SetPoints(newPts) pdo.GetPointData().SetScalars(vals) cirpdo.SetPoints(newPts) cirpdo.GetPointData().SetScalars(vals) aPolyLine = vtk.vtkPolyLine() aPolyLine.GetPointIds().SetNumberOfIds(numPts+1) for i in range(0,numPts): aPolyLine.GetPointIds().SetId(i, i) aPolyLine.GetPointIds().SetId(numPts, 0) cirpdo.Allocate(1, 1) cirpdo.InsertNextCell(aPolyLine.GetCellType(), aPolyLine.GetPointIds()) sphere = vtk.vtkSphereSource() sphere.SetCenter(0, 0, 0) try : sphere.SetRadius(self.radius*gfx.map[0].scale/5.0) except: sphere.SetRadius(self.radius/5.0) sphere.SetThetaResolution(8) sphere.SetStartTheta(0) sphere.SetEndTheta(360) sphere.SetPhiResolution(8) sphere.SetStartPhi(0) sphere.SetEndPhi(180) glyph = vtk.vtkGlyph3D() glyph.SetInput(pdo) glyph.SetColorMode(1) glyph.ScalingOn() glyph.SetScaleMode(2) glyph.SetScaleFactor(0.25) glyph.SetSource(sphere.GetOutput()) self.spheremapper = vtk.vtkPolyDataMapper() self.spheremapper.SetInputConnection(glyph.GetOutputPort()) self.spheremapper.UseLookupTableScalarRangeOff() self.spheremapper.SetScalarVisibility(0) self.sphact = vtk.vtkActor() self.sphact.PickableOff() self.sphact.DragableOff() self.sphact.SetMapper(self.spheremapper) self.sphact.GetProperty().SetRepresentationToSurface() self.sphact.GetProperty().SetInterpolationToGouraud() self.sphact.GetProperty().SetAmbient(0.15) self.sphact.GetProperty().SetDiffuse(0.85) self.sphact.GetProperty().SetSpecular(0.1) self.sphact.GetProperty().SetSpecularPower(100) self.sphact.GetProperty().SetSpecularColor(1, 1, 1) self.sphact.GetProperty().SetColor(1,1,1) self.mapper = vtk.vtkPolyDataMapper() self.mapper.SetScalarVisibility(0) self.mapper.SetInput(cirpdo) self.helact = vtk.vtkActor() self.helact.PickableOff() self.helact.DragableOff() self.helact.GetProperty().SetColor(1,1,1) self.helact.GetProperty().SetRepresentationToWireframe() self.helact.GetProperty().SetLineWidth(5) self.helact.GetProperty().SetLineWidth(1) self.helact.GetProperty().SetSpecular(.4) self.helact.GetProperty().SetSpecularPower(10) self.helact.SetMapper(self.mapper) assembly = vtk.vtkAssembly() assembly.AddPart(self.sphact) assembly.AddPart(self.helact) self.acteur=assembly gfx.renderer.AddActor(self.acteur) gfx.renwin.Render() gfx.ps = self elif self.solidtype=='Dn': numPts = self.dnn shifta = radians(360./numPts) cirpdo = vtk.vtkPolyData() pdo = vtk.vtkPolyData() newPts = vtk.vtkPoints() vals = vtk.vtkDoubleArray() for i in range(0, numPts): try: x = dist * gfx.map[0].scale * cos(i*shifta) y = dist * gfx.map[0].scale * sin(i*shifta) z = 0 except: x = dist * cos(i*shifta) y = dist * sin(i*shifta) z = 0 newPts.InsertPoint(i, x,y,z) vals.InsertNextValue(i) pdo.SetPoints(newPts) pdo.GetPointData().SetScalars(vals) cirpdo.SetPoints(newPts) cirpdo.GetPointData().SetScalars(vals) aPolyLine = vtk.vtkPolyLine() aPolyLine.GetPointIds().SetNumberOfIds(numPts+1) for i in range(0,numPts): aPolyLine.GetPointIds().SetId(i, i) aPolyLine.GetPointIds().SetId(numPts, 0) cirpdo.Allocate(1, 1) cirpdo.InsertNextCell(aPolyLine.GetCellType(), aPolyLine.GetPointIds()) sphere = vtk.vtkSphereSource() sphere.SetCenter(0, 0, 0) try: sphere.SetRadius(self.radius*gfx.map[0].scale/5.0) except: sphere.SetRadius(self.radius/5.0) sphere.SetThetaResolution(8) sphere.SetStartTheta(0) sphere.SetEndTheta(360) sphere.SetPhiResolution(8) sphere.SetStartPhi(0) sphere.SetEndPhi(180) glyph = vtk.vtkGlyph3D() glyph.SetInput(pdo) glyph.SetColorMode(1) glyph.ScalingOn() glyph.SetScaleMode(2) glyph.SetScaleFactor(0.25) glyph.SetSource(sphere.GetOutput()) self.spheremapper = vtk.vtkPolyDataMapper() self.spheremapper.SetInputConnection(glyph.GetOutputPort()) self.spheremapper.UseLookupTableScalarRangeOff() self.spheremapper.SetScalarVisibility(0) self.sphact = vtk.vtkActor() self.sphact.PickableOff() self.sphact.DragableOff() self.sphact.SetMapper(self.spheremapper) self.sphact.GetProperty().SetRepresentationToSurface() self.sphact.GetProperty().SetInterpolationToGouraud() self.sphact.GetProperty().SetAmbient(0.15) self.sphact.GetProperty().SetDiffuse(0.85) self.sphact.GetProperty().SetSpecular(0.1) self.sphact.GetProperty().SetSpecularPower(100) self.sphact.GetProperty().SetSpecularColor(1, 1, 1) self.sphact.GetProperty().SetColor(1,1,1) self.mapper = vtk.vtkPolyDataMapper() self.mapper.SetScalarVisibility(0) self.mapper.SetInput(cirpdo) self.helact = vtk.vtkActor() self.helact.PickableOff() self.helact.DragableOff() self.helact.GetProperty().SetColor(1,1,1) self.helact.GetProperty().SetRepresentationToWireframe() self.helact.GetProperty().SetLineWidth(5) self.helact.GetProperty().SetLineWidth(1) self.helact.GetProperty().SetSpecular(.4) self.helact.GetProperty().SetSpecularPower(10) self.helact.SetMapper(self.mapper) sphact2 = vtk.vtkActor() helact2 = vtk.vtkActor() sphact2.ShallowCopy(self.sphact) helact2.ShallowCopy(self.helact) self.sphact.AddPosition(0,0,dist*c/b) self.helact.AddPosition(0,0,dist*c/b) sphact2.AddPosition(0,0,-dist*c/b) helact2.AddPosition(0,0,-dist*c/b) assembly = vtk.vtkAssembly() assembly.AddPart(self.sphact) assembly.AddPart(self.helact) assembly.AddPart(sphact2) assembly.AddPart(helact2) self.acteur=assembly gfx.renderer.AddActor(self.acteur) gfx.renwin.Render() gfx.ps = self
def prepContinents(fnm): """ This converts vcs continents files to vtkpolydata Author: Charles Doutriaux Input: vcs continent file name """ if vcsContinents.has_key(fnm): return vcsContinents[fnm] poly =vtk.vtkPolyData() cells = vtk.vtkCellArray() pts = vtk.vtkPoints() f=open(fnm) ln=f.readline() while ln.strip().split()!=["-99","-99"]: # Many lines, need to know number of points N = int(ln.split()[0]) # Now create and store these points n=0 npts = pts.GetNumberOfPoints() while n<N: ln=f.readline() sp=ln.split() sn = len(sp) didIt = False if sn%2 == 0: try: spts = [] for i in range(sn/2): l,L = float(sp[i*2]),float(sp[i*2+1]) spts.append([l,L]) for p in spts: pts.InsertNextPoint(p[1],p[0],0.) n+=sn didIt = True except: didIt = False if didIt is False: while len(ln)>2: l,L=float(ln[:8]),float(ln[8:16]) pts.InsertNextPoint(L,l,0.) ln=ln[16:] n+=2 ln = vtk.vtkPolyLine() ln.GetPointIds().SetNumberOfIds(N/2) for i in range(N/2): ln.GetPointIds().SetId(i,i+npts) cells.InsertNextCell(ln) ln=f.readline() poly.SetPoints(pts) poly.SetLines(cells) # The dataset has some duplicate lines that extend outside of x=[-180, 180], # which will cause wrapping artifacts for certain projections (e.g. # Robinson). Clip out the duplicate data: box = vtk.vtkBox() box.SetXMin(-180., -90., 0.) box.SetXMax(180., 90., 1.) clipper = vtk.vtkClipPolyData() clipper.SetInputData(poly) clipper.InsideOutOn() clipper.SetClipFunction(box) clipper.Update() poly = clipper.GetOutput() vcsContinents[fnm]=poly return poly
def testCells(self): # Demonstrates all cell types # # NOTE: the use of NewInstance/DeepCopy is included to increase # regression coverage. It is not required in most applications. ren = vtk.vtkRenderer() # turn off all cullers ren.GetCullers().RemoveAllItems() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) renWin.SetSize(300, 150) iRen = vtk.vtkRenderWindowInteractor() iRen.SetRenderWindow(renWin) # create a scene with one of each cell type # Voxel voxelPoints = vtk.vtkPoints() voxelPoints.SetNumberOfPoints(8) voxelPoints.InsertPoint(0, 0, 0, 0) voxelPoints.InsertPoint(1, 1, 0, 0) voxelPoints.InsertPoint(2, 0, 1, 0) voxelPoints.InsertPoint(3, 1, 1, 0) voxelPoints.InsertPoint(4, 0, 0, 1) voxelPoints.InsertPoint(5, 1, 0, 1) voxelPoints.InsertPoint(6, 0, 1, 1) voxelPoints.InsertPoint(7, 1, 1, 1) aVoxel = vtk.vtkVoxel() aVoxel.GetPointIds().SetId(0, 0) aVoxel.GetPointIds().SetId(1, 1) aVoxel.GetPointIds().SetId(2, 2) aVoxel.GetPointIds().SetId(3, 3) aVoxel.GetPointIds().SetId(4, 4) aVoxel.GetPointIds().SetId(5, 5) aVoxel.GetPointIds().SetId(6, 6) aVoxel.GetPointIds().SetId(7, 7) bVoxel = aVoxel.NewInstance() bVoxel.DeepCopy(aVoxel) aVoxelGrid = vtk.vtkUnstructuredGrid() aVoxelGrid.Allocate(1, 1) aVoxelGrid.InsertNextCell(aVoxel.GetCellType(), aVoxel.GetPointIds()) aVoxelGrid.SetPoints(voxelPoints) aVoxelMapper = vtk.vtkDataSetMapper() aVoxelMapper.SetInputData(aVoxelGrid) aVoxelActor = vtk.vtkActor() aVoxelActor.SetMapper(aVoxelMapper) aVoxelActor.GetProperty().BackfaceCullingOn() # Hexahedron hexahedronPoints = vtk.vtkPoints() hexahedronPoints.SetNumberOfPoints(8) hexahedronPoints.InsertPoint(0, 0, 0, 0) hexahedronPoints.InsertPoint(1, 1, 0, 0) hexahedronPoints.InsertPoint(2, 1, 1, 0) hexahedronPoints.InsertPoint(3, 0, 1, 0) hexahedronPoints.InsertPoint(4, 0, 0, 1) hexahedronPoints.InsertPoint(5, 1, 0, 1) hexahedronPoints.InsertPoint(6, 1, 1, 1) hexahedronPoints.InsertPoint(7, 0, 1, 1) aHexahedron = vtk.vtkHexahedron() aHexahedron.GetPointIds().SetId(0, 0) aHexahedron.GetPointIds().SetId(1, 1) aHexahedron.GetPointIds().SetId(2, 2) aHexahedron.GetPointIds().SetId(3, 3) aHexahedron.GetPointIds().SetId(4, 4) aHexahedron.GetPointIds().SetId(5, 5) aHexahedron.GetPointIds().SetId(6, 6) aHexahedron.GetPointIds().SetId(7, 7) bHexahedron = aHexahedron.NewInstance() bHexahedron.DeepCopy(aHexahedron) aHexahedronGrid = vtk.vtkUnstructuredGrid() aHexahedronGrid.Allocate(1, 1) aHexahedronGrid.InsertNextCell(aHexahedron.GetCellType(), aHexahedron.GetPointIds()) aHexahedronGrid.SetPoints(hexahedronPoints) aHexahedronMapper = vtk.vtkDataSetMapper() aHexahedronMapper.SetInputData(aHexahedronGrid) aHexahedronActor = vtk.vtkActor() aHexahedronActor.SetMapper(aHexahedronMapper) aHexahedronActor.AddPosition(2, 0, 0) aHexahedronActor.GetProperty().BackfaceCullingOn() # Tetra tetraPoints = vtk.vtkPoints() tetraPoints.SetNumberOfPoints(4) tetraPoints.InsertPoint(0, 0, 0, 0) tetraPoints.InsertPoint(1, 1, 0, 0) tetraPoints.InsertPoint(2, 0.5, 1, 0) tetraPoints.InsertPoint(3, 0.5, 0.5, 1) aTetra = vtk.vtkTetra() aTetra.GetPointIds().SetId(0, 0) aTetra.GetPointIds().SetId(1, 1) aTetra.GetPointIds().SetId(2, 2) aTetra.GetPointIds().SetId(3, 3) bTetra = aTetra.NewInstance() bTetra.DeepCopy(aTetra) aTetraGrid = vtk.vtkUnstructuredGrid() aTetraGrid.Allocate(1, 1) aTetraGrid.InsertNextCell(aTetra.GetCellType(), aTetra.GetPointIds()) aTetraGrid.SetPoints(tetraPoints) aTetraCopy = vtk.vtkUnstructuredGrid() aTetraCopy.ShallowCopy(aTetraGrid) aTetraMapper = vtk.vtkDataSetMapper() aTetraMapper.SetInputData(aTetraCopy) aTetraActor = vtk.vtkActor() aTetraActor.SetMapper(aTetraMapper) aTetraActor.AddPosition(4, 0, 0) aTetraActor.GetProperty().BackfaceCullingOn() # Wedge wedgePoints = vtk.vtkPoints() wedgePoints.SetNumberOfPoints(6) wedgePoints.InsertPoint(0, 0, 1, 0) wedgePoints.InsertPoint(1, 0, 0, 0) wedgePoints.InsertPoint(2, 0, 0.5, 0.5) wedgePoints.InsertPoint(3, 1, 1, 0) wedgePoints.InsertPoint(4, 1, 0, 0) wedgePoints.InsertPoint(5, 1, 0.5, 0.5) aWedge = vtk.vtkWedge() aWedge.GetPointIds().SetId(0, 0) aWedge.GetPointIds().SetId(1, 1) aWedge.GetPointIds().SetId(2, 2) aWedge.GetPointIds().SetId(3, 3) aWedge.GetPointIds().SetId(4, 4) aWedge.GetPointIds().SetId(5, 5) bWedge = aWedge.NewInstance() bWedge.DeepCopy(aWedge) aWedgeGrid = vtk.vtkUnstructuredGrid() aWedgeGrid.Allocate(1, 1) aWedgeGrid.InsertNextCell(aWedge.GetCellType(), aWedge.GetPointIds()) aWedgeGrid.SetPoints(wedgePoints) aWedgeCopy = vtk.vtkUnstructuredGrid() aWedgeCopy.DeepCopy(aWedgeGrid) aWedgeMapper = vtk.vtkDataSetMapper() aWedgeMapper.SetInputData(aWedgeCopy) aWedgeActor = vtk.vtkActor() aWedgeActor.SetMapper(aWedgeMapper) aWedgeActor.AddPosition(6, 0, 0) aWedgeActor.GetProperty().BackfaceCullingOn() # Pyramid pyramidPoints = vtk.vtkPoints() pyramidPoints.SetNumberOfPoints(5) pyramidPoints.InsertPoint(0, 0, 0, 0) pyramidPoints.InsertPoint(1, 1, 0, 0) pyramidPoints.InsertPoint(2, 1, 1, 0) pyramidPoints.InsertPoint(3, 0, 1, 0) pyramidPoints.InsertPoint(4, 0.5, 0.5, 1) aPyramid = vtk.vtkPyramid() aPyramid.GetPointIds().SetId(0, 0) aPyramid.GetPointIds().SetId(1, 1) aPyramid.GetPointIds().SetId(2, 2) aPyramid.GetPointIds().SetId(3, 3) aPyramid.GetPointIds().SetId(4, 4) bPyramid = aPyramid.NewInstance() bPyramid.DeepCopy(aPyramid) aPyramidGrid = vtk.vtkUnstructuredGrid() aPyramidGrid.Allocate(1, 1) aPyramidGrid.InsertNextCell(aPyramid.GetCellType(), aPyramid.GetPointIds()) aPyramidGrid.SetPoints(pyramidPoints) aPyramidMapper = vtk.vtkDataSetMapper() aPyramidMapper.SetInputData(aPyramidGrid) aPyramidActor = vtk.vtkActor() aPyramidActor.SetMapper(aPyramidMapper) aPyramidActor.AddPosition(8, 0, 0) aPyramidActor.GetProperty().BackfaceCullingOn() # Pixel pixelPoints = vtk.vtkPoints() pixelPoints.SetNumberOfPoints(4) pixelPoints.InsertPoint(0, 0, 0, 0) pixelPoints.InsertPoint(1, 1, 0, 0) pixelPoints.InsertPoint(2, 0, 1, 0) pixelPoints.InsertPoint(3, 1, 1, 0) aPixel = vtk.vtkPixel() aPixel.GetPointIds().SetId(0, 0) aPixel.GetPointIds().SetId(1, 1) aPixel.GetPointIds().SetId(2, 2) aPixel.GetPointIds().SetId(3, 3) bPixel = aPixel.NewInstance() bPixel.DeepCopy(aPixel) aPixelGrid = vtk.vtkUnstructuredGrid() aPixelGrid.Allocate(1, 1) aPixelGrid.InsertNextCell(aPixel.GetCellType(), aPixel.GetPointIds()) aPixelGrid.SetPoints(pixelPoints) aPixelMapper = vtk.vtkDataSetMapper() aPixelMapper.SetInputData(aPixelGrid) aPixelActor = vtk.vtkActor() aPixelActor.SetMapper(aPixelMapper) aPixelActor.AddPosition(0, 0, 2) aPixelActor.GetProperty().BackfaceCullingOn() # Quad quadPoints = vtk.vtkPoints() quadPoints.SetNumberOfPoints(4) quadPoints.InsertPoint(0, 0, 0, 0) quadPoints.InsertPoint(1, 1, 0, 0) quadPoints.InsertPoint(2, 1, 1, 0) quadPoints.InsertPoint(3, 0, 1, 0) aQuad = vtk.vtkQuad() aQuad.GetPointIds().SetId(0, 0) aQuad.GetPointIds().SetId(1, 1) aQuad.GetPointIds().SetId(2, 2) aQuad.GetPointIds().SetId(3, 3) bQuad = aQuad.NewInstance() bQuad.DeepCopy(aQuad) aQuadGrid = vtk.vtkUnstructuredGrid() aQuadGrid.Allocate(1, 1) aQuadGrid.InsertNextCell(aQuad.GetCellType(), aQuad.GetPointIds()) aQuadGrid.SetPoints(quadPoints) aQuadMapper = vtk.vtkDataSetMapper() aQuadMapper.SetInputData(aQuadGrid) aQuadActor = vtk.vtkActor() aQuadActor.SetMapper(aQuadMapper) aQuadActor.AddPosition(2, 0, 2) aQuadActor.GetProperty().BackfaceCullingOn() # Triangle trianglePoints = vtk.vtkPoints() trianglePoints.SetNumberOfPoints(3) trianglePoints.InsertPoint(0, 0, 0, 0) trianglePoints.InsertPoint(1, 1, 0, 0) trianglePoints.InsertPoint(2, 0.5, 0.5, 0) triangleTCoords = vtk.vtkFloatArray() triangleTCoords.SetNumberOfComponents(2) triangleTCoords.SetNumberOfTuples(3) triangleTCoords.InsertTuple2(0, 1, 1) triangleTCoords.InsertTuple2(1, 2, 2) triangleTCoords.InsertTuple2(2, 3, 3) aTriangle = vtk.vtkTriangle() aTriangle.GetPointIds().SetId(0, 0) aTriangle.GetPointIds().SetId(1, 1) aTriangle.GetPointIds().SetId(2, 2) bTriangle = aTriangle.NewInstance() bTriangle.DeepCopy(aTriangle) aTriangleGrid = vtk.vtkUnstructuredGrid() aTriangleGrid.Allocate(1, 1) aTriangleGrid.InsertNextCell(aTriangle.GetCellType(), aTriangle.GetPointIds()) aTriangleGrid.SetPoints(trianglePoints) aTriangleGrid.GetPointData().SetTCoords(triangleTCoords) aTriangleMapper = vtk.vtkDataSetMapper() aTriangleMapper.SetInputData(aTriangleGrid) aTriangleActor = vtk.vtkActor() aTriangleActor.SetMapper(aTriangleMapper) aTriangleActor.AddPosition(4, 0, 2) aTriangleActor.GetProperty().BackfaceCullingOn() # Polygon polygonPoints = vtk.vtkPoints() polygonPoints.SetNumberOfPoints(4) polygonPoints.InsertPoint(0, 0, 0, 0) polygonPoints.InsertPoint(1, 1, 0, 0) polygonPoints.InsertPoint(2, 1, 1, 0) polygonPoints.InsertPoint(3, 0, 1, 0) aPolygon = vtk.vtkPolygon() aPolygon.GetPointIds().SetNumberOfIds(4) aPolygon.GetPointIds().SetId(0, 0) aPolygon.GetPointIds().SetId(1, 1) aPolygon.GetPointIds().SetId(2, 2) aPolygon.GetPointIds().SetId(3, 3) bPolygon = aPolygon.NewInstance() bPolygon.DeepCopy(aPolygon) aPolygonGrid = vtk.vtkUnstructuredGrid() aPolygonGrid.Allocate(1, 1) aPolygonGrid.InsertNextCell(aPolygon.GetCellType(), aPolygon.GetPointIds()) aPolygonGrid.SetPoints(polygonPoints) aPolygonMapper = vtk.vtkDataSetMapper() aPolygonMapper.SetInputData(aPolygonGrid) aPolygonActor = vtk.vtkActor() aPolygonActor.SetMapper(aPolygonMapper) aPolygonActor.AddPosition(6, 0, 2) aPolygonActor.GetProperty().BackfaceCullingOn() # Triangle Strip triangleStripPoints = vtk.vtkPoints() triangleStripPoints.SetNumberOfPoints(5) triangleStripPoints.InsertPoint(0, 0, 1, 0) triangleStripPoints.InsertPoint(1, 0, 0, 0) triangleStripPoints.InsertPoint(2, 1, 1, 0) triangleStripPoints.InsertPoint(3, 1, 0, 0) triangleStripPoints.InsertPoint(4, 2, 1, 0) triangleStripTCoords = vtk.vtkFloatArray() triangleStripTCoords.SetNumberOfComponents(2) triangleStripTCoords.SetNumberOfTuples(3) triangleStripTCoords.InsertTuple2(0, 1, 1) triangleStripTCoords.InsertTuple2(1, 2, 2) triangleStripTCoords.InsertTuple2(2, 3, 3) triangleStripTCoords.InsertTuple2(3, 4, 4) triangleStripTCoords.InsertTuple2(4, 5, 5) aTriangleStrip = vtk.vtkTriangleStrip() aTriangleStrip.GetPointIds().SetNumberOfIds(5) aTriangleStrip.GetPointIds().SetId(0, 0) aTriangleStrip.GetPointIds().SetId(1, 1) aTriangleStrip.GetPointIds().SetId(2, 2) aTriangleStrip.GetPointIds().SetId(3, 3) aTriangleStrip.GetPointIds().SetId(4, 4) bTriangleStrip = aTriangleStrip.NewInstance() bTriangleStrip.DeepCopy(aTriangleStrip) aTriangleStripGrid = vtk.vtkUnstructuredGrid() aTriangleStripGrid.Allocate(1, 1) aTriangleStripGrid.InsertNextCell(aTriangleStrip.GetCellType(), aTriangleStrip.GetPointIds()) aTriangleStripGrid.SetPoints(triangleStripPoints) aTriangleStripGrid.GetPointData().SetTCoords(triangleStripTCoords) aTriangleStripMapper = vtk.vtkDataSetMapper() aTriangleStripMapper.SetInputData(aTriangleStripGrid) aTriangleStripActor = vtk.vtkActor() aTriangleStripActor.SetMapper(aTriangleStripMapper) aTriangleStripActor.AddPosition(8, 0, 2) aTriangleStripActor.GetProperty().BackfaceCullingOn() # Line linePoints = vtk.vtkPoints() linePoints.SetNumberOfPoints(2) linePoints.InsertPoint(0, 0, 0, 0) linePoints.InsertPoint(1, 1, 1, 0) aLine = vtk.vtkLine() aLine.GetPointIds().SetId(0, 0) aLine.GetPointIds().SetId(1, 1) bLine = aLine.NewInstance() bLine.DeepCopy(aLine) aLineGrid = vtk.vtkUnstructuredGrid() aLineGrid.Allocate(1, 1) aLineGrid.InsertNextCell(aLine.GetCellType(), aLine.GetPointIds()) aLineGrid.SetPoints(linePoints) aLineMapper = vtk.vtkDataSetMapper() aLineMapper.SetInputData(aLineGrid) aLineActor = vtk.vtkActor() aLineActor.SetMapper(aLineMapper) aLineActor.AddPosition(0, 0, 4) aLineActor.GetProperty().BackfaceCullingOn() # Poly line polyLinePoints = vtk.vtkPoints() polyLinePoints.SetNumberOfPoints(3) polyLinePoints.InsertPoint(0, 0, 0, 0) polyLinePoints.InsertPoint(1, 1, 1, 0) polyLinePoints.InsertPoint(2, 1, 0, 0) aPolyLine = vtk.vtkPolyLine() aPolyLine.GetPointIds().SetNumberOfIds(3) aPolyLine.GetPointIds().SetId(0, 0) aPolyLine.GetPointIds().SetId(1, 1) aPolyLine.GetPointIds().SetId(2, 2) bPolyLine = aPolyLine.NewInstance() bPolyLine.DeepCopy(aPolyLine) aPolyLineGrid = vtk.vtkUnstructuredGrid() aPolyLineGrid.Allocate(1, 1) aPolyLineGrid.InsertNextCell(aPolyLine.GetCellType(), aPolyLine.GetPointIds()) aPolyLineGrid.SetPoints(polyLinePoints) aPolyLineMapper = vtk.vtkDataSetMapper() aPolyLineMapper.SetInputData(aPolyLineGrid) aPolyLineActor = vtk.vtkActor() aPolyLineActor.SetMapper(aPolyLineMapper) aPolyLineActor.AddPosition(2, 0, 4) aPolyLineActor.GetProperty().BackfaceCullingOn() # Vertex vertexPoints = vtk.vtkPoints() vertexPoints.SetNumberOfPoints(1) vertexPoints.InsertPoint(0, 0, 0, 0) aVertex = vtk.vtkVertex() aVertex.GetPointIds().SetId(0, 0) bVertex = aVertex.NewInstance() bVertex.DeepCopy(aVertex) aVertexGrid = vtk.vtkUnstructuredGrid() aVertexGrid.Allocate(1, 1) aVertexGrid.InsertNextCell(aVertex.GetCellType(), aVertex.GetPointIds()) aVertexGrid.SetPoints(vertexPoints) aVertexMapper = vtk.vtkDataSetMapper() aVertexMapper.SetInputData(aVertexGrid) aVertexActor = vtk.vtkActor() aVertexActor.SetMapper(aVertexMapper) aVertexActor.AddPosition(0, 0, 6) aVertexActor.GetProperty().BackfaceCullingOn() # Poly Vertex polyVertexPoints = vtk.vtkPoints() polyVertexPoints.SetNumberOfPoints(3) polyVertexPoints.InsertPoint(0, 0, 0, 0) polyVertexPoints.InsertPoint(1, 1, 0, 0) polyVertexPoints.InsertPoint(2, 1, 1, 0) aPolyVertex = vtk.vtkPolyVertex() aPolyVertex.GetPointIds().SetNumberOfIds(3) aPolyVertex.GetPointIds().SetId(0, 0) aPolyVertex.GetPointIds().SetId(1, 1) aPolyVertex.GetPointIds().SetId(2, 2) bPolyVertex = aPolyVertex.NewInstance() bPolyVertex.DeepCopy(aPolyVertex) aPolyVertexGrid = vtk.vtkUnstructuredGrid() aPolyVertexGrid.Allocate(1, 1) aPolyVertexGrid.InsertNextCell(aPolyVertex.GetCellType(), aPolyVertex.GetPointIds()) aPolyVertexGrid.SetPoints(polyVertexPoints) aPolyVertexMapper = vtk.vtkDataSetMapper() aPolyVertexMapper.SetInputData(aPolyVertexGrid) aPolyVertexActor = vtk.vtkActor() aPolyVertexActor.SetMapper(aPolyVertexMapper) aPolyVertexActor.AddPosition(2, 0, 6) aPolyVertexActor.GetProperty().BackfaceCullingOn() # Pentagonal prism pentaPoints = vtk.vtkPoints() pentaPoints.SetNumberOfPoints(10) pentaPoints.InsertPoint(0, 0.25, 0.0, 0.0) pentaPoints.InsertPoint(1, 0.75, 0.0, 0.0) pentaPoints.InsertPoint(2, 1.0, 0.5, 0.0) pentaPoints.InsertPoint(3, 0.5, 1.0, 0.0) pentaPoints.InsertPoint(4, 0.0, 0.5, 0.0) pentaPoints.InsertPoint(5, 0.25, 0.0, 1.0) pentaPoints.InsertPoint(6, 0.75, 0.0, 1.0) pentaPoints.InsertPoint(7, 1.0, 0.5, 1.0) pentaPoints.InsertPoint(8, 0.5, 1.0, 1.0) pentaPoints.InsertPoint(9, 0.0, 0.5, 1.0) aPenta = vtk.vtkPentagonalPrism() aPenta.GetPointIds().SetId(0, 0) aPenta.GetPointIds().SetId(1, 1) aPenta.GetPointIds().SetId(2, 2) aPenta.GetPointIds().SetId(3, 3) aPenta.GetPointIds().SetId(4, 4) aPenta.GetPointIds().SetId(5, 5) aPenta.GetPointIds().SetId(6, 6) aPenta.GetPointIds().SetId(7, 7) aPenta.GetPointIds().SetId(8, 8) aPenta.GetPointIds().SetId(9, 9) bPenta = aPenta.NewInstance() bPenta.DeepCopy(aPenta) aPentaGrid = vtk.vtkUnstructuredGrid() aPentaGrid.Allocate(1, 1) aPentaGrid.InsertNextCell(aPenta.GetCellType(), aPenta.GetPointIds()) aPentaGrid.SetPoints(pentaPoints) aPentaCopy = vtk.vtkUnstructuredGrid() aPentaCopy.DeepCopy(aPentaGrid) aPentaMapper = vtk.vtkDataSetMapper() aPentaMapper.SetInputData(aPentaCopy) aPentaActor = vtk.vtkActor() aPentaActor.SetMapper(aPentaMapper) aPentaActor.AddPosition(10, 0, 0) aPentaActor.GetProperty().BackfaceCullingOn() # Hexagonal prism hexaPoints = vtk.vtkPoints() hexaPoints.SetNumberOfPoints(12) hexaPoints.InsertPoint(0, 0.0, 0.0, 0.0) hexaPoints.InsertPoint(1, 0.5, 0.0, 0.0) hexaPoints.InsertPoint(2, 1.0, 0.5, 0.0) hexaPoints.InsertPoint(3, 1.0, 1.0, 0.0) hexaPoints.InsertPoint(4, 0.5, 1.0, 0.0) hexaPoints.InsertPoint(5, 0.0, 0.5, 0.0) hexaPoints.InsertPoint(6, 0.0, 0.0, 1.0) hexaPoints.InsertPoint(7, 0.5, 0.0, 1.0) hexaPoints.InsertPoint(8, 1.0, 0.5, 1.0) hexaPoints.InsertPoint(9, 1.0, 1.0, 1.0) hexaPoints.InsertPoint(10, 0.5, 1.0, 1.0) hexaPoints.InsertPoint(11, 0.0, 0.5, 1.0) aHexa = vtk.vtkHexagonalPrism() aHexa.GetPointIds().SetId(0, 0) aHexa.GetPointIds().SetId(1, 1) aHexa.GetPointIds().SetId(2, 2) aHexa.GetPointIds().SetId(3, 3) aHexa.GetPointIds().SetId(4, 4) aHexa.GetPointIds().SetId(5, 5) aHexa.GetPointIds().SetId(6, 6) aHexa.GetPointIds().SetId(7, 7) aHexa.GetPointIds().SetId(8, 8) aHexa.GetPointIds().SetId(9, 9) aHexa.GetPointIds().SetId(10, 10) aHexa.GetPointIds().SetId(11, 11) bHexa = aHexa.NewInstance() bHexa.DeepCopy(aHexa) aHexaGrid = vtk.vtkUnstructuredGrid() aHexaGrid.Allocate(1, 1) aHexaGrid.InsertNextCell(aHexa.GetCellType(), aHexa.GetPointIds()) aHexaGrid.SetPoints(hexaPoints) aHexaCopy = vtk.vtkUnstructuredGrid() aHexaCopy.DeepCopy(aHexaGrid) aHexaMapper = vtk.vtkDataSetMapper() aHexaMapper.SetInputData(aHexaCopy) aHexaActor = vtk.vtkActor() aHexaActor.SetMapper(aHexaMapper) aHexaActor.AddPosition(12, 0, 0) aHexaActor.GetProperty().BackfaceCullingOn() # RIB property aRIBProperty = vtk.vtkRIBProperty() aRIBProperty.SetVariable("Km", "float") aRIBProperty.SetSurfaceShader("LGVeinedmarble") aRIBProperty.SetVariable("veinfreq", "float") aRIBProperty.AddVariable("warpfreq", "float") aRIBProperty.AddVariable("veincolor", "color") aRIBProperty.AddParameter("veinfreq", " 2") aRIBProperty.AddParameter("veincolor", "1.0000 1.0000 0.9412") bRIBProperty = vtk.vtkRIBProperty() bRIBProperty.SetVariable("Km", "float") bRIBProperty.SetParameter("Km", "1.0") bRIBProperty.SetDisplacementShader("dented") bRIBProperty.SetSurfaceShader("plastic") aProperty = vtk.vtkProperty() bProperty = vtk.vtkProperty() aTriangleActor.SetProperty(aProperty) aTriangleStripActor.SetProperty(bProperty) ren.SetBackground(0.1, 0.2, 0.4) ren.AddActor(aVoxelActor) aVoxelActor.GetProperty().SetDiffuseColor(1, 0, 0) ren.AddActor(aHexahedronActor) aHexahedronActor.GetProperty().SetDiffuseColor(1, 1, 0) ren.AddActor(aTetraActor) aTetraActor.GetProperty().SetDiffuseColor(0, 1, 0) ren.AddActor(aWedgeActor) aWedgeActor.GetProperty().SetDiffuseColor(0, 1, 1) ren.AddActor(aPyramidActor) aPyramidActor.GetProperty().SetDiffuseColor(1, 0, 1) ren.AddActor(aPixelActor) aPixelActor.GetProperty().SetDiffuseColor(0, 1, 1) ren.AddActor(aQuadActor) aQuadActor.GetProperty().SetDiffuseColor(1, 0, 1) ren.AddActor(aTriangleActor) aTriangleActor.GetProperty().SetDiffuseColor(0.3, 1, 0.5) ren.AddActor(aPolygonActor) aPolygonActor.GetProperty().SetDiffuseColor(1, 0.4, 0.5) ren.AddActor(aTriangleStripActor) aTriangleStripActor.GetProperty().SetDiffuseColor(0.3, 0.7, 1) ren.AddActor(aLineActor) aLineActor.GetProperty().SetDiffuseColor(0.2, 1, 1) ren.AddActor(aPolyLineActor) aPolyLineActor.GetProperty().SetDiffuseColor(1, 1, 1) ren.AddActor(aVertexActor) aVertexActor.GetProperty().SetDiffuseColor(1, 1, 1) ren.AddActor(aPolyVertexActor) aPolyVertexActor.GetProperty().SetDiffuseColor(1, 1, 1) ren.AddActor(aPentaActor) aPentaActor.GetProperty().SetDiffuseColor(0.2, 0.4, 0.7) ren.AddActor(aHexaActor) aHexaActor.GetProperty().SetDiffuseColor(0.7, 0.5, 1) aRIBLight = vtk.vtkRIBLight() aRIBLight.ShadowsOn() aLight = vtk.vtkLight() aLight.PositionalOn() aLight.SetConeAngle(25) ren.AddLight(aLight) ren.ResetCamera() ren.GetActiveCamera().Azimuth(30) ren.GetActiveCamera().Elevation(20) ren.GetActiveCamera().Dolly(2.8) ren.ResetCameraClippingRange() aLight.SetFocalPoint(ren.GetActiveCamera().GetFocalPoint()) aLight.SetPosition(ren.GetActiveCamera().GetPosition()) # write to the temp directory if possible, otherwise use . dir = tempfile.gettempdir() atext = vtk.vtkTexture() pnmReader = vtk.vtkBMPReader() pnmReader.SetFileName(VTK_DATA_ROOT + "/Data/masonry.bmp") atext.SetInputConnection(pnmReader.GetOutputPort()) atext.InterpolateOff() aTriangleActor.SetTexture(atext) rib = vtk.vtkRIBExporter() rib.SetInput(renWin) rib.SetFilePrefix(dir + "/cells") rib.SetTexturePrefix(dir + "/cells") rib.Write() os.remove(dir + "/cells.rib") iv = vtk.vtkIVExporter() iv.SetInput(renWin) iv.SetFileName(dir + "/cells.iv") iv.Write() os.remove(dir + "/cells.iv") obj = vtk.vtkOBJExporter() obj.SetInput(renWin) obj.SetFilePrefix(dir + "/cells") obj.Write() os.remove(dir + "/cells.obj") os.remove(dir + "/cells.mtl") vrml = vtk.vtkVRMLExporter() vrml.SetInput(renWin) # vrml.SetStartWrite(vrml.SetFileName(dir + "/cells.wrl")) # vrml.SetEndWrite(vrml.SetFileName("/a/acells.wrl")) vrml.SetFileName(dir + "/cells.wrl") vrml.SetSpeed(5.5) vrml.Write() os.remove(dir + "/cells.wrl") oogl = vtk.vtkOOGLExporter() oogl.SetInput(renWin) oogl.SetFileName(dir + "/cells.oogl") oogl.Write() os.remove(dir + "/cells.oogl") # the UnRegister calls are because make object is the same as New, # and causes memory leaks. (Python does not treat NewInstance the same as New). def DeleteCopies(): bVoxel.UnRegister(None) bHexahedron.UnRegister(None) bTetra.UnRegister(None) bWedge.UnRegister(None) bPyramid.UnRegister(None) bPixel.UnRegister(None) bQuad.UnRegister(None) bTriangle.UnRegister(None) bPolygon.UnRegister(None) bTriangleStrip.UnRegister(None) bLine.UnRegister(None) bPolyLine.UnRegister(None) bVertex.UnRegister(None) bPolyVertex.UnRegister(None) bPenta.UnRegister(None) bHexa.UnRegister(None) DeleteCopies() # render and interact with data renWin.Render() img_file = "cells.png" vtk.test.Testing.compareImage(iRen.GetRenderWindow(), vtk.test.Testing.getAbsImagePath(img_file), threshold=25) vtk.test.Testing.interact()
def BuildCentreline(segmentList, firstId = 0, firstPt = (0.0,0.0,0.0), direction = 0.0): print 'Processing centreline:', segmentList domain = None try: domain = segmentList[0] except IndexError: sys.exit("Missing domain length in list " + str(list) + ".") if isinstance(domain, tuple): domainLength = domain[0] angle = math.radians(domain[1]) else: if not isinstance(domain, (int, float, long)): sys.exit("Domain length should be a number, not a(an) " + str(type(domainLength)) + ".") angle = branchAngle domainLength = domain leftBranch = None try: leftBranch = segmentList[1] except IndexError: pass rightBranch = None try: rightBranch = segmentList[2] except IndexError: pass line = vtk.vtkPolyLine() if direction < 0: angle = math.pi - angle for pId in range (0, int(domainLength / step) + 1): nextPt = ((firstPt[0] + (1.0 if direction == 0.0 else math.sin(angle)) * (step * pId)) * scaling, \ (firstPt[1] + (1.0 if direction == 0.0 else math.cos(angle)) * (step * pId) * direction) * scaling , \ firstPt[2] * scaling) if sphereRadius != None: longitude = nextPt[0] / sphereRadius latitude = 2 * math.atan(math.exp(nextPt[1] / sphereRadius)) - math.pi / 2.0 nextPtS = (sphereRadius * math.cos(latitude) * math.cos(longitude),\ sphereRadius * math.cos(latitude) * math.sin(longitude),\ sphereRadius * math.sin(latitude)) if firstId == 0 or pId > 0: nextId = points.InsertNextPoint(nextPtS) else: nextId = firstId else: if firstId == 0 or pId > 0: nextId = points.InsertNextPoint(nextPt) else: nextId = firstId line.GetPointIds().InsertNextId(nextId) lines.InsertNextCell(line) if isinstance(leftBranch, list): BuildCentreline(leftBranch, nextId, nextPt, 1.0) if isinstance(rightBranch, list): BuildCentreline(rightBranch, nextId, nextPt, -1.0)
def init_draw(self, fiber, ren, **kwargs): # Convert color to rgb. my_color = kwargs.get('color', 'b') label = kwargs.get('label', '') rgb_color = 255 * colorConverter.to_rgba(my_color) # Create a vtkPoints instance. points = vtk.vtkPoints() self.points = points poly_line = vtk.vtkPolyLine() nb_points = fiber.get_nb_points() poly_line.GetPointIds().SetNumberOfIds(nb_points) for i in range(nb_points): poly_line.GetPointIds().SetId(i, i) self.points.InsertNextPoint(fiber.get_points()[i]) cells = vtk.vtkCellArray() cells.InsertNextCell(poly_line) poly_data = vtk.vtkPolyData() poly_data.SetPoints(points) poly_data.SetLines(cells) # The tube is wrapped around the generated streamline. stream_tube = vtk.vtkTubeFilter() self.tube = stream_tube if major_version <= 5: stream_tube.SetInput(poly_data) else: stream_tube.SetInputData(poly_data) stream_tube.SetRadius(fiber.get_radius()) stream_tube.SetNumberOfSides(12) stream_tube.SetCapping(True) map_stream_tube = vtk.vtkPolyDataMapper() map_stream_tube.SetInputConnection(stream_tube.GetOutputPort()) actor = vtk.vtkActor() actor.SetMapper(map_stream_tube) actor.GetProperty().SetColor(rgb_color[0], rgb_color[1], rgb_color[2]) ren.AddActor(actor) self.actor = actor # Add label to the figure text_source = vtk.vtkVectorText() text_source.SetText(label) text_source.Update() text_mapper = vtk.vtkPolyDataMapper() text_mapper.SetInputConnection(text_source.GetOutputPort()) text_actor1 = vtk.vtkActor() text_actor1.SetMapper(text_mapper) text_actor1.GetProperty().SetColor(rgb_color[0], rgb_color[1], rgb_color[2]) text_actor1.SetScale(1.0) center1 = text_actor1.GetCenter() text_actor1.RotateX(90) text_actor1.AddPosition(fiber.get_points()[-1] * 1.2 - center1) text_actor2 = vtk.vtkActor() text_actor2.SetMapper(text_mapper) text_actor2.GetProperty().SetColor(rgb_color[0], rgb_color[1], rgb_color[2]) text_actor2.SetScale(1.0) center2 = text_actor2.GetCenter() text_actor2.RotateX(90) text_actor2.AddPosition(fiber.get_points()[0] * 1.2 - center2) ren.AddActor(text_actor1) ren.AddActor(text_actor2)