def __init__(self, module_manager): # initialise our base class ModuleBase.__init__(self, module_manager) # initialise any mixins we might have NoConfigModuleMixin.__init__(self) self._distance = vtk.vtkImageEuclideanDistance() # this seems to yield more accurate results in this case # it would probably be better to calculate only 2d distance fields self._distance.ConsiderAnisotropyOff() self._xEndPoints = [] self._noFlipXes = [] self._pf1 = vtk.vtkProgrammableFilter() # yeah self._pf1.SetInput(self._distance.GetOutput()) self._pf1.SetExecuteMethod(self.pf1Execute) self._pf2 = vtk.vtkProgrammableFilter() self._pf2.SetInput(self._pf1.GetOutput()) self._pf2.SetExecuteMethod(self.pf2Execute) self._mc = vtk.vtkMarchingCubes() self._mc.SetInput(self._pf1.GetOutput()) self._mc.SetValue(0, 0.1) self._iv = vtk.vtkImplicitVolume() self._iv.SetVolume(self._pf2.GetOutput()) self._cpd = vtk.vtkClipPolyData() self._cpd.SetClipFunction(self._iv) self._cpd.SetInput(self._mc.GetOutput()) #self._cpd.InsideOutOn() module_utils.setup_vtk_object_progress( self, self._distance, 'Calculating distance field...') module_utils.setup_vtk_object_progress(self, self._pf1, 'Signing distance field...') module_utils.setup_vtk_object_progress(self, self._pf2, 'Creating implicit volume...') module_utils.setup_vtk_object_progress(self, self._mc, 'Extracting isosurface...') module_utils.setup_vtk_object_progress(self, self._cpd, 'Clipping isosurface...') self._iObj = self._distance self._oObj = self._cpd #self._oObj = self._pf2 self._viewFrame = self._createViewFrame({ 'distance': self._distance, 'pf1': self._pf1, 'pf2': self._pf2, 'mc': self._mc, 'cpd': self._cpd })
def tessellation_callback(tessellation, size_of_cell1, tolerance1): input_data = tessellation.GetPolyDataInput() output_data = tessellation.GetPolyDataOutput() output_data.ShallowCopy(input_data) # Triangulate Surface. triangle_data = vtk.vtkTriangleFilter() triangle_data.SetInputData(output_data) triangle_data.Update() triangulated_model = triangle_data.GetOutput() number_of_polys = triangulated_model.GetNumberOfPolys() append_filter = vtk.vtkAppendPolyData() # Iterate over triangles. for i in range(0, 40): # Apply point generation filter. cell_index = i point_generation = vtk.vtkProgrammableFilter() point_generation.AddInputData(triangulated_model) point_generation.SetExecuteMethod( pointGenerationFilterBase.point_generation_callback( point_generation, cell_index, size_of_cell1)) current_polydata = point_generation.GetPolyDataOutput() # Append current triangulation polyData to total model polyData. append_filter.AddInputData(current_polydata) append_filter.Update() # Triangulate current cells generated points. delaunay2D = vtk.vtkDelaunay2D() delaunay2D.SetInputData(append_filter.GetOutput()) delaunay2D.SetSourceData(append_filter.GetOutput()) delaunay2D.SetTolerance(tolerance1) delaunay2D.Update() # Remove degenerate triangles and remove duplicate points. cleaner = vtk.vtkCleanPolyData() cleaner.SetInputData(delaunay2D.GetOutput()) cleaner.Update() polygonation = vtk.vtkProgrammableFilter() polygonation.AddInputData(cleaner.GetOutput()) polygonation.SetExecuteMethod( polygonation3DBase.polygonation_callback(polygonation)) output_data.SetPolys(polygonation.GetOutput().GetPolys()) output_data.SetPoints(polygonation.GetOutput().GetPoints())
def __init__(self, module_manager): SimpleVTKClassModuleBase.__init__( self, module_manager, vtk.vtkProgrammableFilter(), 'Processing.', ('vtkDataSet',), ('vtkDataSet',), replaceDoc=True, inputFunctions=None, outputFunctions=None)
def __init__(self, module_manager): SimpleVTKClassModuleBase.__init__(self, module_manager, vtk.vtkProgrammableFilter(), 'Processing.', ('vtkDataSet', ), ('vtkDataSet', ), replaceDoc=True, inputFunctions=None, outputFunctions=None)
def __init__(self, instance, data_name='velocity', data_size=6): self._instance = instance self._data_name = data_name self._data_size = data_size self._connector = vtk.vtkProgrammableFilter() self._connector.SetExecuteMethod(self.method) self._data = numpy.zeros(data_size) self._vtk_data = vtk.vtkFloatArray() self._vtk_data.SetName(data_name) self._vtk_data.SetNumberOfComponents(data_size) self._vtk_data.SetNumberOfTuples(1)
def create_pipeline(): reader = get_mesh_source(mesh_file_name) pf = vtk.vtkProgrammableFilter() pf.SetInputConnection(reader.GetOutputPort()) algo = PluginAlgorithm(pf) pf.SetExecuteMethod(algo) renWin, iren = create_scene(pf, reader) # some additional customization renWin.SetWindowName("Demo plugin") renWin.Render() time.sleep(3) iren.Start()
def main(): # Read in data set. reader = vtk.vtkXMLPolyDataReader() reader.SetFileName("quadMeshFullc4080.vtp") reader.Update() cleaner = vtk.vtkCleanPolyData() cleaner.SetInputConnection(reader.GetOutputPort()) cleaner.Update() # Apply tessellation filter. tessellation = vtk.vtkProgrammableFilter() tessellation.AddInputConnection(cleaner.GetOutputPort()) tessellation.SetExecuteMethod( tessellation_callback(tessellation, 250, 0.008)) # Set up mapper. mapper = vtk.vtkPolyDataMapper() mapper.SetInputData(tessellation.GetOutput()) mapper.ScalarVisibilityOff() # Set up actor. actor = vtk.vtkLODActor() actor.SetMapper(mapper) # Render. ren = vtk.vtkRenderer() ren_win = vtk.vtkRenderWindow() ren_win.AddRenderer(ren) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(ren_win) # Add the actors to the renderer, set the background and size. ren.AddActor(actor) ren.SetBackground(0.1, 0.2, 0.4) ren_win.SetSize(800, 800) # Start event. iren.Initialize() ren_win.Render() iren.Start()
def make_models(self): """ make models """ # We create a 100 by 100 point plane to sample self.plane = vtk.vtkPlaneSource() self.plane.SetXResolution(self.resolution) self.plane.SetYResolution(self.resolution) # We transform the plane by a factor of 10 on X and Y and 1 Z transform = vtk.vtkTransform() transform.Scale(10, 10, 1) transF = vtk.vtkTransformPolyDataFilter() transF.SetInputConnection(self.plane.GetOutputPort()) transF.SetTransform(transform) # Compute Bessel function and derivatives. We'll use a programmable filter # for this. Note the unusual GetPolyDataInput() & GetOutputPort() methods. besselF = vtk.vtkProgrammableFilter() besselF.SetInputConnection(transF.GetOutputPort()) # The SetExecuteMethod takes a Python function as an argument # In here is where all the processing is done. def bessel(): inputs = besselF.GetPolyDataInput() numPts = inputs.GetNumberOfPoints() newPts = vtk.vtkPoints() derivs = vtk.vtkFloatArray() for i in xrange(0, numPts): x = inputs.GetPoint(i) x0, x1 = x[:2] r = sqrt(x0*x0+x1*x1) x2 = exp(-r)*cos(self.factor*r) deriv = -exp(-r)*(cos(self.factor*r)+self.factor*sin(self.factor*r)) newPts.InsertPoint(i, x0, x1, x2) derivs.InsertValue(i, deriv) besselF.GetPolyDataOutput().CopyStructure(inputs) besselF.GetPolyDataOutput().SetPoints(newPts) besselF.GetPolyDataOutput().GetPointData().SetScalars(derivs) besselF.SetExecuteMethod(bessel) # We warp the plane based on the scalar values calculated above warp = vtk.vtkWarpScalar() warp.SetInputConnection(besselF.GetOutputPort()) warp.XYPlaneOn() warp.SetScaleFactor(self.scale_factor) # We create a mapper and actor as usual. In the case we adjust the # scalar range of the mapper to match that of the computed scalars mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(warp.GetOutputPort()) mapper.SetScalarRange(besselF.GetPolyDataOutput().GetScalarRange()) carpet = vtk.vtkActor() carpet.SetMapper(mapper) self.surface_actor = carpet outline = vtk.vtkOutlineFilter() outline.SetInputConnection(warp.GetOutputPort()) outline_mapper = vtk.vtkPolyDataMapper() outline_mapper.SetInputConnection(outline.GetOutputPort()) self.outline_actor = vtk.vtkActor() self.outline_actor.SetMapper(outline_mapper) self.outline_actor.GetProperty().SetColor(0, 0, 0) self.warp_geometry = warp
plane.SetYResolution(100) # # We transform the plane by a factor of 10 on X and Y # transform = vtk.vtkTransform() transform.Scale(10, 10, 1) transF = vtk.vtkTransformPolyDataFilter() transF.SetPolyDataInput(plane.GetPolyDataOutput) transF.SetTransform(transform) # # Compute Bessel function and derivatives. We'll use a programmable filter # for this. Note the unusual GetInput() & GetOutput() methods. # besselF = vtk.vtkProgrammableFilter() besselF.SetInput(transf.GetOutput()) besselF.SetExecuteMethode(besel) # # The SetExecuteMethod takes a Tcl proc as an argument # In here is where all the processing is done. # def bessel(): input = besselF.GetPolyDataInput() numPts = input.GetNumberOfPoints() newPts = vtk.vtkPoints() derivs = vtk.vtkFloatArray()
def _setup_pipeline(self): ren = vtk.vtkRenderer() ren.SetBackground(1.0, 1.0, 1.0) color_points = vtk.vtkProgrammableFilter() def callback_color_points(): input_ = color_points.GetInput() output = color_points.GetOutput() output.ShallowCopy(input_) lookup = vtk.vtkFloatArray() lookup.SetNumberOfValues(input_.GetNumberOfPoints()) npy_lookup = vtk_to_numpy(lookup) npy_lookup.flat = self._k.astype( np.float32) / (COLORMAP.shape[0] - 1) output.GetPointData().SetScalars(lookup) color_points.SetExecuteMethod(callback_color_points) source = vtk.vtkCubeSource() vertices_glyph = vtk.vtkGlyph3D() vertices_glyph.SetInputConnection(color_points.GetOutputPort()) vertices_glyph.SetSourceConnection(source.GetOutputPort()) vertices_glyph.SetScaleModeToDataScalingOff() vertices_glyph.SetColorModeToColorByScalar() vertices_mapper = vtk.vtkPolyDataMapper() vertices_mapper.SetInputConnection(vertices_glyph.GetOutputPort()) vertices_mapper.SetLookupTable(LUT) vertices_actor = vtk.vtkActor() vertices_actor.SetMapper(vertices_mapper) vertices_actor.GetProperty().SetColor(*COLORMAP[0, :3]) vertices_actor.PickableOff() vertices_actor.VisibilityOff() ren.AddActor(vertices_actor) color_faces = vtk.vtkProgrammableFilter() def callback_color_faces(): input_ = color_faces.GetInput() output = color_faces.GetOutput() output.ShallowCopy(input_) lookup = vtk.vtkFloatArray() lookup.SetNumberOfValues(input_.GetNumberOfPolys()) npy_lookup = vtk_to_numpy(lookup) labelled_T = self._k[self.T] for i in xrange(input_.GetNumberOfPolys()): l = np.argmax(np.bincount(labelled_T[i])) npy_lookup[i] = float(l) / (COLORMAP.shape[0] - 1) output.GetCellData().SetScalars(lookup) color_faces.SetExecuteMethod(callback_color_faces) model_mapper = vtk.vtkPolyDataMapper() model_mapper.SetInputConnection(color_faces.GetOutputPort()) model_mapper.SetLookupTable(LUT) model_actor = vtk.vtkActor() model_actor.SetMapper(model_mapper) model_actor.GetProperty().SetColor(*COLORMAP[0, :3]) model_actor.VisibilityOff() ren.AddActor(model_actor) render_window = vtk.vtkRenderWindow() render_window.AddRenderer(ren) render_window.SetSize(400, 400) self.SetRenderWindow(render_window) visible = vtk.vtkSelectVisiblePoints() visible.SetRenderer(ren) picker = vtk.vtkAreaPicker() def callback_picker(obj, event): props = obj.GetProp3Ds() if props.GetNumberOfItems() <= 0: return extract_geometry = vtk.vtkExtractGeometry() extract_geometry.SetImplicitFunction(picker.GetFrustum()) extract_geometry.SetInput(visible.GetInput()) extract_geometry.Update() unstructured_grid = extract_geometry.GetOutput() if unstructured_grid.GetPoints().GetNumberOfPoints() <= 0: return i = vtk_to_numpy(unstructured_grid.GetPointData().GetArray('i')) if self.select_only_visible: visible.Update() if visible.GetOutput().GetPoints().GetNumberOfPoints() <= 0: return i = np.intersect1d( i, vtk_to_numpy( visible.GetOutput().GetPointData().GetArray('i'))) if i.shape[0] <= 0: return self.set_labels(self.current_label, i) picker.AddObserver('EndPickEvent', callback_picker) iren = self.GetInteractor() iren.SetRenderWindow(render_window) iren.SetPicker(picker) style = vtk.vtkInteractorStyleRubberBandPick() style.SetCurrentRenderer(ren) iren.SetInteractorStyle(style) self.pipeline = locals() self.setSizePolicy(QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Expanding)
from __future__ import print_function import vtk from vtk.util.misc import vtkGetTempDir VTK_TEMP_DIR = vtkGetTempDir() contr = vtk.vtkMultiProcessController.GetGlobalController() if not contr: nranks = 1 rank = 0 else: nranks = contr.GetNumberOfProcesses() rank = contr.GetLocalProcessId() pf = vtk.vtkProgrammableFilter() def execute(): info = pf.GetOutputInformation(0) et = vtk.vtkExtentTranslator() et.SetWholeExtent( info.Get(vtk.vtkStreamingDemandDrivenPipeline.WHOLE_EXTENT())) et.SetPiece( info.Get(vtk.vtkStreamingDemandDrivenPipeline.UPDATE_PIECE_NUMBER())) et.SetNumberOfPieces( info.Get( vtk.vtkStreamingDemandDrivenPipeline.UPDATE_NUMBER_OF_PIECES())) et.PieceToExtent() output = pf.GetOutput() input = pf.GetInput() output.ShallowCopy(input)
reader.SetFilePrefix("" + str(VTK_DATA_ROOT) + "/Data/headsq/quarter") reader.SetDataMask(0x7fff) reader.SetDataSpacing(1.6,1.6,1.5) clipper = vtk.vtkImageClip() clipper.SetInputConnection(reader.GetOutputPort()) clipper.SetOutputWholeExtent(30,36,30,36,30,36) clipper2 = vtk.vtkImageClip() clipper2.SetInputConnection(reader.GetOutputPort()) clipper2.SetOutputWholeExtent(30,36,30,36,30,36) tris = vtk.vtkDataSetTriangleFilter() tris.SetInputConnection(clipper.GetOutputPort()) tris2 = vtk.vtkDataSetTriangleFilter() tris2.SetInputConnection(clipper2.GetOutputPort()) geom = vtk.vtkGeometryFilter() geom.SetInputConnection(tris.GetOutputPort()) pf = vtk.vtkProgrammableFilter() pf.SetInputConnection(tris2.GetOutputPort()) def remove_ghosts(): input = pf.GetInput() output = pf.GetOutputDataObject(0) output.ShallowCopy(input) output.RemoveGhostCells() pf.SetExecuteMethod(remove_ghosts) edges = vtk.vtkExtractEdges() edges.SetInputConnection(pf.GetOutputPort()) mapper1 = vtk.vtkPolyDataMapper() mapper1.SetInputConnection(geom.GetOutputPort()) mapper1.ScalarVisibilityOn() mapper1.SetScalarRange(0,1200) mapper1.SetPiece(PIECE) mapper1.SetNumberOfPieces(NUMBER_OF_PIECES)
def testDeciPlane(self): # Create the RenderWindow, Renderer and both Actors # ren1 = vtk.vtkRenderer() ren2 = vtk.vtkRenderer() ren3 = vtk.vtkRenderer() ren4 = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren1) renWin.AddRenderer(ren2) renWin.AddRenderer(ren3) renWin.AddRenderer(ren4) # Create the data -- a plane with a couple of bumps # plane = vtk.vtkPlaneSource() plane.SetXResolution(10) plane.SetYResolution(10) tf = vtk.vtkTriangleFilter() tf.SetInputConnection(plane.GetOutputPort()) tf.Update() def adjustPointsProc(): input = adjustPoints.GetPolyDataInput() inPts = input.GetPoints() numPts = input.GetNumberOfPoints() newPts = vtk.vtkPoints() newPts.SetNumberOfPoints(numPts) for i in range(0, numPts): newPts.SetPoint(i, inPts.GetPoint(i)) pt = input.GetPoint(17) newPts.SetPoint(17, pt[0], pt[1], 0.25) pt = inPts.GetPoint(50) newPts.SetPoint(50, pt[0], pt[1], 1.0) pt = inPts.GetPoint(77) newPts.SetPoint(77, pt[0], pt[1], 0.125) adjustPoints.GetPolyDataOutput().CopyStructure(input) adjustPoints.GetPolyDataOutput().SetPoints(newPts) # This filter modifies the point coordinates in a couple of spots # adjustPoints = vtk.vtkProgrammableFilter() adjustPoints.SetInputConnection(tf.GetOutputPort()) # The SetExecuteMethod takes a python procedure as an argument # In here is where all the processing is done. adjustPoints.SetExecuteMethod(adjustPointsProc()) #adjustPoints.Update() # Now remove the extreme peak in the center gf = vtk.vtkGeometryFilter() gf.SetInputData(adjustPoints.GetPolyDataOutput()) gf.ExtentClippingOn() gf.SetExtent(-100, 100, -100, 100, -1, 0.9) # Create a table of decimation conditions # boundaryVertexDeletion = ["On", "Off"] accumulates = ["On", "Off"] deci = dict() mapper = dict() plane = dict() #sz = len(boundaryVertexDeletion) for topology in boundaryVertexDeletion: for accumulate in accumulates: # idx = i * sz + j idx = topology + accumulate deci.update({idx: vtk.vtkDecimatePro()}) deci[idx].SetInputConnection(gf.GetOutputPort()) deci[idx].SetTargetReduction(.95) if topology == "On": deci[idx].BoundaryVertexDeletionOn() elif topology == "Off": deci[idx].BoundaryVertexDeletionOff() if accumulate == "On": deci[idx].AccumulateErrorOn() elif accumulate == "Off": deci[idx].AccumulateErrorOff() mapper.update({idx: vtk.vtkPolyDataMapper()}) mapper[idx].SetInputConnection(deci[idx].GetOutputPort()) plane.update({idx: vtk.vtkActor()}) plane[idx].SetMapper(mapper[idx]) # Add the actors to the renderer, set the background and size # ren1.SetViewport(0, .5, .5, 1) ren2.SetViewport(.5, .5, 1, 1) ren3.SetViewport(0, 0, .5, .5) ren4.SetViewport(.5, 0, 1, .5) ren1.AddActor(plane["OnOn"]) ren2.AddActor(plane["OnOff"]) ren3.AddActor(plane["OffOn"]) ren4.AddActor(plane["OffOff"]) camera = vtk.vtkCamera() ren1.SetActiveCamera(camera) ren2.SetActiveCamera(camera) ren3.SetActiveCamera(camera) ren4.SetActiveCamera(camera) ren1.GetActiveCamera().SetPosition(-0.128224, 0.611836, 2.31297) ren1.GetActiveCamera().SetFocalPoint(0, 0, 0.125) ren1.GetActiveCamera().SetViewAngle(30) ren1.GetActiveCamera().SetViewUp(0.162675, 0.952658, -0.256864) ren1.SetBackground(0, 0, 0) ren2.SetBackground(0, 0, 0) ren3.SetBackground(0, 0, 0) ren4.SetBackground(0, 0, 0) renWin.SetSize(500, 500) # render and interact with data iRen = vtk.vtkRenderWindowInteractor() iRen.SetRenderWindow(renWin); renWin.Render() img_file = "deciPlane.png" vtk.test.Testing.compareImage(iRen.GetRenderWindow(), vtk.test.Testing.getAbsImagePath(img_file), threshold=25) vtk.test.Testing.interact()
newArray.SetValue(idx * 3 + 2, int(value / 256 / 256)) # if idx % progress == 0: # count = count + 1 # print count # # sys.stdout.write('.') # # sys.stdout.flush() # #sys. "\rProcessing %s: %d %s" % (array.GetName(), count, "/-\\|"[count%4]) print # Pipeline writer = vtkPNGWriter() reader = vtkXMLImageDataReader() filter = vtkProgrammableFilter() filter.SetExecuteMethod(unfoldData) # Loop over files to process idx = 0 for fileName in fileNames: directory = outputDir + ('/%d/' % idx) # Make sure the destination directory exist if not os.path.exists(directory): os.makedirs(directory) reader.SetFileName(basePath + '/' + fileName) reader.Update() filter.SetInputData(reader.GetOutput())
def __init__(self) : self.Filter = vtk.vtkProgrammableFilter() self.Filter.SetExecuteMethod(self.ExecMethod)
def __init__(self): self.Filter = vtk.vtkProgrammableFilter() self.Filter.SetExecuteMethod(self.ExecMethod)
def bessel_surface(): """ programmable surface """ # We create a 100 by 100 point plane to sample plane = vtk.vtkPlaneSource() plane.SetXResolution(100) plane.SetYResolution(100) # We transform the plane by a factor of 10 on X and Y transform = vtk.vtkTransform() transform.Scale(10, 10, 1) transF = vtk.vtkTransformPolyDataFilter() transF.SetInputConnection(plane.GetOutputPort()) transF.SetTransform(transform) # Compute Bessel function and derivatives. We'll use a programmable filter # for this. Note the unusual GetPolyDataInput() & GetOutputPort() methods. besselF = vtk.vtkProgrammableFilter() besselF.SetInputConnection(transF.GetOutputPort()) # The SetExecuteMethod takes a Python function as an argument # In here is where all the processing is done. def bessel(): inputs = besselF.GetPolyDataInput() numPts = inputs.GetNumberOfPoints() newPts = vtk.vtkPoints() derivs = vtk.vtkFloatArray() for i in xrange(0, numPts): x = inputs.GetPoint(i) x0, x1 = x[:2] r = sqrt(x0*x0+x1*x1) x2 = exp(-r)*cos(10.0*r) deriv = -exp(-r)*(cos(10.0*r)+10.0*sin(10.0*r)) newPts.InsertPoint(i, x0, x1, x2) derivs.InsertValue(i, deriv) besselF.GetPolyDataOutput().CopyStructure(inputs) besselF.GetPolyDataOutput().SetPoints(newPts) besselF.GetPolyDataOutput().GetPointData().SetScalars(derivs) besselF.SetExecuteMethod(bessel) # We warp the plane based on the scalar values calculated above warp = vtk.vtkWarpScalar() warp.SetInputConnection(besselF.GetOutputPort()) warp.XYPlaneOn() warp.SetScaleFactor(0.5) # We create a mapper and actor as usual. In the case we adjust the # scalar range of the mapper to match that of the computed scalars mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(warp.GetOutputPort()) mapper.SetScalarRange(besselF.GetPolyDataOutput().GetScalarRange()) carpet = vtk.vtkActor() carpet.SetMapper(mapper) return carpet
def __init__(self, module_manager): # initialise our base class ModuleBase.__init__(self, module_manager) # initialise any mixins we might have NoConfigModuleMixin.__init__(self) self._distance = vtk.vtkImageEuclideanDistance() # this seems to yield more accurate results in this case # it would probably be better to calculate only 2d distance fields self._distance.ConsiderAnisotropyOff() self._xEndPoints = [] self._noFlipXes = [] self._pf1 = vtk.vtkProgrammableFilter() # yeah self._pf1.SetInput(self._distance.GetOutput()) self._pf1.SetExecuteMethod(self.pf1Execute) self._pf2 = vtk.vtkProgrammableFilter() self._pf2.SetInput(self._pf1.GetOutput()) self._pf2.SetExecuteMethod(self.pf2Execute) self._mc = vtk.vtkMarchingCubes() self._mc.SetInput(self._pf1.GetOutput()) self._mc.SetValue(0,0.1) self._iv = vtk.vtkImplicitVolume() self._iv.SetVolume(self._pf2.GetOutput()) self._cpd = vtk.vtkClipPolyData() self._cpd.SetClipFunction(self._iv) self._cpd.SetInput(self._mc.GetOutput()) #self._cpd.InsideOutOn() module_utils.setup_vtk_object_progress(self, self._distance, 'Calculating distance field...') module_utils.setup_vtk_object_progress(self, self._pf1, 'Signing distance field...') module_utils.setup_vtk_object_progress(self, self._pf2, 'Creating implicit volume...') module_utils.setup_vtk_object_progress(self, self._mc, 'Extracting isosurface...') module_utils.setup_vtk_object_progress(self, self._cpd, 'Clipping isosurface...') self._iObj = self._distance self._oObj = self._cpd #self._oObj = self._pf2 self._viewFrame = self._createViewFrame({'distance' : self._distance, 'pf1' : self._pf1, 'pf2' : self._pf2, 'mc' : self._mc, 'cpd' : self._cpd})
def __init__(self, renderer, surfaceSize): ''' Initialize the terrain. This is derived from the expCos.py example on the vtk.org website, link is above. ''' # Call the parent constructor super(Terrain,self).__init__(renderer) # We create a 'surfaceSize' by 'surfaceSize' point plane to sample plane = vtk.vtkPlaneSource() plane.SetXResolution(surfaceSize) plane.SetYResolution(surfaceSize) # We transform the plane by a factor of 'surfaceSize' on X and Y transform = vtk.vtkTransform() transform.Scale(surfaceSize, surfaceSize, 1) transF = vtk.vtkTransformPolyDataFilter() transF.SetInputConnection(plane.GetOutputPort()) transF.SetTransform(transform) # Compute the function that we use for the height generation. # [Original comment] Note the unusual GetPolyDataInput() & GetOutputPort() methods. surfaceF = vtk.vtkProgrammableFilter() surfaceF.SetInputConnection(transF.GetOutputPort()) # [Original comment] The SetExecuteMethod takes a Python function as an argument # In here is where all the processing is done. def bessel(): input = surfaceF.GetPolyDataInput() numPts = input.GetNumberOfPoints() newPts = vtk.vtkPoints() derivs = vtk.vtkFloatArray() for i in range(0, numPts): x = input.GetPoint(i) x, z = x[:2] # Get the XY plane point, which we'll make an XZ plane point so that's it a ground surface - this is a convenient point to remap it... # Now do your surface construction here, which we'll just make an arbitrary wavy surface for now. y = sin(x / float(surfaceSize) * 6.282) * cos(z / float(surfaceSize) * 6.282) newPts.InsertPoint(i, x, y, z) derivs.InsertValue(i, y) surfaceF.GetPolyDataOutput().CopyStructure(input) surfaceF.GetPolyDataOutput().SetPoints(newPts) surfaceF.GetPolyDataOutput().GetPointData().SetScalars(derivs) surfaceF.SetExecuteMethod(bessel) # We warp the plane based on the scalar values calculated above warp = vtk.vtkWarpScalar() warp.SetInputConnection(surfaceF.GetOutputPort()) warp.XYPlaneOn() # Set the range of the colour mapper to the function min/max we used to generate the terrain. mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(warp.GetOutputPort()) mapper.SetScalarRange(-1, 1) # Make our terrain wireframe so that it doesn't occlude the whole scene self.vtkActor.GetProperty().SetRepresentationToWireframe() # Finally assign this to the parent class actor so that it draws. self.vtkActor.SetMapper(mapper) # [HACK] Got tired of picking terrain [Alucard] self.vtkActor.PickableOff()
#!/Users/seb/Work/code/ParaView/build/bin/pvpython import sys from vtk import vtkMetaImageReader, vtkProgrammableFilter, vtkUnsignedCharArray, vtkJPEGWriter, vtkPNGWriter basePath = '/Users/seb/Work/projects/NE-Phase2/' reader = vtkMetaImageReader() reader.SetFileName("/Users/seb/Work/projects/NE-Phase2/Patient05.mha") reader.Update() writer = vtkJPEGWriter() # vtkJPEGWriter() filter = vtkProgrammableFilter() def unfoldData(): inputDS = filter.GetInputDataObject(0, 0) outputDS = filter.GetImageDataOutput() dims = inputDS.GetDimensions() # dims[1] * dims[2] nbSlices = (dims[1] * dims[2]) / 2048 outputDS.SetDimensions(dims[0], dims[1] * dims[2] / nbSlices, nbSlices) outputDS.SetOrigin(0,0,0) outputDS.SetSpacing(1,1,1) for arrayIdx in range(inputDS.GetPointData().GetNumberOfArrays()): array = inputDS.GetPointData().GetArray(arrayIdx) size = dims[0] * dims[1] * dims[2]
# We create a 100 by 100 point plane to sample plane = vtk.vtkPlaneSource() plane.SetXResolution(100) plane.SetYResolution(100) # We transform the plane by a factor of 10 on X and Y transform = vtk.vtkTransform() transform.Scale(10, 10, 1) transF = vtk.vtkTransformPolyDataFilter() transF.SetInputConnection(plane.GetOutputPort()) transF.SetTransform(transform) # Compute Bessel function and derivatives. We'll use a programmable filter # for this. Note the unusual GetPolyDataInput() & GetOutputPort() methods. besselF = vtk.vtkProgrammableFilter() besselF.SetInputConnection(transF.GetOutputPort()) # The SetExecuteMethod takes a Python function as an argument # In here is where all the processing is done. def bessel(): input = besselF.GetPolyDataInput() numPts = input.GetNumberOfPoints() newPts = vtk.vtkPoints() derivs = vtk.vtkFloatArray() for i in range(0, numPts): x = input.GetPoint(i) x0, x1 = x[:2] r = sqrt(x0*x0+x1*x1)