def __init__(self, module_manager): SimpleVTKClassModuleBase.__init__( self, module_manager, vtk.vtkGaussianSplatter(), 'Processing.', ('vtkDataSet',), ('vtkImageData',), replaceDoc=True, inputFunctions=None, outputFunctions=None)
def __init__(self, module_manager): SimpleVTKClassModuleBase.__init__(self, module_manager, vtk.vtkGaussianSplatter(), 'Processing.', ('vtkDataSet', ), ('vtkImageData', ), replaceDoc=True, inputFunctions=None, outputFunctions=None)
def run_source(): """https://www.creatis.insa-lyon.fr/~davila/bbtk/Software/new/doc/VTK_Documentation/report-about-vtk-2007-02.pdf""" pointSource = get_point_source() popSplatter = vtk.vtkGaussianSplatter() # Splatter : popSplatter.SetSampleDimensions(300, 300, 300) # points -> gauss sphere popSplatter.SetInputConnection(pointSource.GetOutputPort()) # f(x) = scale * exp ( expF *(( r/ Radius )^2) ) popSplatter.SetRadius(0.1) popSplatter.SetExponentFactor(1.0) popSplatter.SetScaleFactor(1.0) cast = vtk.vtkImageCast() # uchar conversion cast.SetInputConnection( popSplatter.GetOutputPort()) # ( required by VRayCast ) cast.SetOutputScalarTypeToUnsignedChar() alphaTF = vtk.vtkPiecewiseFunction() # Opacity (A-TF) alphaTF.AddPoint(0, 0) alphaTF.AddPoint(1, 0.01) alphaTF.AddPoint(255, 0.5) colorTF = vtk.vtkColorTransferFunction() # Color (RGB -TF) colorTF.AddRGBPoint(0, 1, 0.4, 0) colorTF.AddRGBPoint(255, 1, 0.0, 0) volumeProperty = vtk.vtkVolumeProperty() # Property volumeProperty.SetColor(colorTF) volumeProperty.SetScalarOpacity(alphaTF) volumeProperty.SetInterpolationTypeToLinear() #compositeFunction = vtkVolumeRayCastCompositeFunction()# Mapper volumeMapper = vtk.vtkFixedPointVolumeRayCastMapper() # ( Software ) #volumeMapper.SetVolumeRayCastFunction(compositeFunction) volumeMapper.SetBlendModeToComposite() volumeMapper.SetInputConnection(cast.GetOutputPort()) volume = vtk.vtkVolume() # Volume = Mapper + Property volume.SetMapper(volumeMapper) volume.SetProperty(volumeProperty) ren = vtk.vtkRenderer() # Renderer ren.AddVolume(volume) ren.ResetCamera() ren.GetActiveCamera().ParallelProjectionOn() renwin = vtk.vtkRenderWindow() # Window renwin.AddRenderer(ren) renwin.SetSize(300, 300) renwin.SetDesiredUpdateRate(1.0) iren = vtk.vtkRenderWindowInteractor() # Interactor iren.SetRenderWindow(renwin) iren.Start()
def __init__(self, parent = None): super(VTKFrame, self).__init__(parent) self.vtkWidget = QVTKRenderWindowInteractor(self) vl = QtGui.QVBoxLayout(self) vl.addWidget(self.vtkWidget) vl.setContentsMargins(0, 0, 0, 0) self.ren = vtk.vtkRenderer() self.ren.SetBackground(0.1, 0.2, 0.4) self.vtkWidget.GetRenderWindow().AddRenderer(self.ren) self.iren = self.vtkWidget.GetRenderWindow().GetInteractor() # Create source sphereSource = vtk.vtkSphereSource() sphereSource.Update() polydata = vtk.vtkPolyData() polydata.SetPoints(sphereSource.GetOutput().GetPoints()) splatter = vtk.vtkGaussianSplatter() splatter.SetInput(polydata) splatter.SetSampleDimensions(50, 50, 50) splatter.SetRadius(0.05) splatter.ScalarWarpingOff() surface = vtk.vtkContourFilter() surface.SetInputConnection(splatter.GetOutputPort()) surface.SetValue(0, 0.01) # Create a mapper mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(surface.GetOutputPort()) # Create an actor actor = vtk.vtkActor() actor.SetMapper(mapper) self.ren.AddActor(actor) self.ren.ResetCamera() self._initialized = False
def __init__(self, parent=None): super(VTKFrame, self).__init__(parent) self.vtkWidget = QVTKRenderWindowInteractor(self) vl = QtGui.QVBoxLayout(self) vl.addWidget(self.vtkWidget) vl.setContentsMargins(0, 0, 0, 0) self.ren = vtk.vtkRenderer() self.ren.SetBackground(0.1, 0.2, 0.4) self.vtkWidget.GetRenderWindow().AddRenderer(self.ren) self.iren = self.vtkWidget.GetRenderWindow().GetInteractor() # Create source sphereSource = vtk.vtkSphereSource() sphereSource.Update() polydata = vtk.vtkPolyData() polydata.SetPoints(sphereSource.GetOutput().GetPoints()) splatter = vtk.vtkGaussianSplatter() splatter.SetInput(polydata) splatter.SetSampleDimensions(50, 50, 50) splatter.SetRadius(0.05) splatter.ScalarWarpingOff() surface = vtk.vtkContourFilter() surface.SetInputConnection(splatter.GetOutputPort()) surface.SetValue(0, 0.01) # Create a mapper mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(surface.GetOutputPort()) # Create an actor actor = vtk.vtkActor() actor.SetMapper(mapper) self.ren.AddActor(actor) self.ren.ResetCamera() self._initialized = False
def main(): # Create points on a sphere sphereSource = vtk.vtkSphereSource() sphereSource.Update() colors = vtk.vtkNamedColors() polydata = vtk.vtkPolyData() polydata.SetPoints(sphereSource.GetOutput().GetPoints()) splatter = vtk.vtkGaussianSplatter() splatter.SetInputData(polydata) splatter.SetSampleDimensions(50, 50, 50) splatter.SetRadius(0.5) splatter.ScalarWarpingOff() surface = vtk.vtkContourFilter() surface.SetInputConnection(splatter.GetOutputPort()) surface.SetValue(0, 0.01) # Create a mapper and actor mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(surface.GetOutputPort()) actor = vtk.vtkActor() actor.SetMapper(mapper) # Visualize renderer = vtk.vtkRenderer() renderWindow = vtk.vtkRenderWindow() renderWindow.AddRenderer(renderer) renderWindowInteractor = vtk.vtkRenderWindowInteractor() renderWindowInteractor.SetRenderWindow(renderWindow) renderer.AddActor(actor) renderer.SetBackground(colors.GetColor3d('SteelBlue')) renderWindow.SetWindowName('GaussianSplat') renderWindow.Render() renderWindowInteractor.Start()
# represent the array scalar (TIME_LATE) calc.AddScalarVariable("s", scalar, 0) # Divide scalar by max (applies division to all components of the array) calc.SetFunction("s / %f"%max) # The output array will be called resArray calc.SetResultArrayName("resArray") # Use AssignAttribute to make resArray the active scalar field aa = vtk.vtkAssignAttribute() aa.SetInputConnection(calc.GetOutputPort()) aa.Assign("resArray", "SCALARS", "POINT_DATA") aa.Update() # construct pipeline for original population # GaussianSplatter -> Contour -> Mapper -> Actor popSplatter = vtk.vtkGaussianSplatter() popSplatter.SetInputConnection(aa.GetOutputPort()) popSplatter.SetSampleDimensions(50, 50, 50) popSplatter.SetRadius(0.05) popSplatter.ScalarWarpingOff() popSurface = vtk.vtkContourFilter() popSurface.SetInputConnection(popSplatter.GetOutputPort()) popSurface.SetValue(0, 0.01) popMapper = vtk.vtkPolyDataMapper() popMapper.SetInputConnection(popSurface.GetOutputPort()) popMapper.ScalarVisibilityOff() popActor = vtk.vtkActor() popActor.SetMapper(popMapper)
def main(): colors = vtk.vtkNamedColors() colors.SetColor("PopColor", [230, 230, 230, 255]) # fileName = get_program_parameters() keys = ['NUMBER_POINTS', 'MONTHLY_PAYMENT', 'INTEREST_RATE', 'LOAN_AMOUNT', 'TIME_LATE'] # Read in the data and make an unstructured data set. dataSet = make_dataset() # pts[:,0] = pts[:,0] ** 3 # npData.SetPoints(npData.GetPoints()) # # Construct the pipeline for the original population. # popSplatter = vtk.vtkGaussianSplatter() # popSplatter.SetInputData(dataSet) # popSplatter.SetSampleDimensions(100, 100, 100) # popSplatter.SetRadius(0.1) # popSplatter.ScalarWarpingOff() # popSurface = vtk.vtkContourFilter() # popSurface.SetInputConnection(popSplatter.GetOutputPort()) # popSurface.SetValue(0, 0.01) # popMapper = vtk.vtkPolyDataMapper() # popMapper.SetInputConnection(popSurface.GetOutputPort()) # popMapper.ScalarVisibilityOff() # popActor = vtk.vtkActor() # popActor.SetMapper(popMapper) # popActor.GetProperty().SetOpacity(0.3) # popActor.GetProperty().SetColor(colors.GetColor3d("PopColor")) # Construct the pipeline for the delinquent population. lateSplatter = vtk.vtkGaussianSplatter() lateSplatter.SetInputData(dataSet) lateSplatter.SetSampleDimensions(150, 150, 150) lateSplatter.SetRadius(0.1) lateSplatter.SetScaleFactor(.001) lateSurface = vtk.vtkContourFilter() lateSurface.SetInputConnection(lateSplatter.GetOutputPort()) lateSurface.SetValue(0, 0.01) lateMapper = vtk.vtkPolyDataMapper() lateMapper.SetInputConnection(lateSurface.GetOutputPort()) lateMapper.ScalarVisibilityOff() lateActor = vtk.vtkActor() lateActor.SetMapper(lateMapper) lateActor.GetProperty().SetColor(colors.GetColor3d("Red")) # Create axes. lateSplatter.Update() bounds = lateSplatter.GetOutput().GetBounds() axes = vtk.vtkAxes() axes.SetOrigin(bounds[0], bounds[2], bounds[4]) axes.SetScaleFactor(lateSplatter.GetOutput().GetLength() / 5) axesTubes = vtk.vtkTubeFilter() axesTubes.SetInputConnection(axes.GetOutputPort()) axesTubes.SetRadius(axes.GetScaleFactor() / 25.0) axesTubes.SetNumberOfSides(6) axesMapper = vtk.vtkPolyDataMapper() axesMapper.SetInputConnection(axesTubes.GetOutputPort()) axesActor = vtk.vtkActor() axesActor.SetMapper(axesMapper) # Visualize. renderer = vtk.vtkRenderer() renderWindow = vtk.vtkRenderWindow() renderWindow.AddRenderer(renderer) interactor = vtk.vtkRenderWindowInteractor() interactor.SetRenderWindow(renderWindow) renderer.AddActor(axesActor) renderer.AddActor(lateActor) renderer.SetBackground(colors.GetColor3d("powder_blue")) # Enable user interface interactor renderWindow.Render() def update(self): pts = dataSet.GetPoints() pts.SetPoint(0, [0,0,np.sin(time.time())]) pts.Modified() interactor.Render() # Sign up to receive TimerEvent cb = vtkTimerCallback() cb.update = update interactor.AddObserver('TimerEvent', cb.execute) timerId = interactor.CreateRepeatingTimer(10); interactor.Start()
def testFinancialField(self): size = 3187 #maximum number possible #set size 100 #maximum number possible xAxis = "INTEREST_RATE" yAxis = "MONTHLY_PAYMENT" zAxis = "MONTHLY_INCOME" scalar = "TIME_LATE" # extract data from field as a polydata (just points), then extract scalars fdr = vtk.vtkDataObjectReader() fdr.SetFileName(VTK_DATA_ROOT + "/Data/financial.vtk") do2ds = vtk.vtkDataObjectToDataSetFilter() do2ds.SetInputConnection(fdr.GetOutputPort()) do2ds.SetDataSetTypeToPolyData() #format: component#, arrayname, arraycomp, minArrayId, maxArrayId, normalize do2ds.DefaultNormalizeOn() do2ds.SetPointComponent(0, xAxis, 0) do2ds.SetPointComponent(1, yAxis, 0, 0, size, 1) do2ds.SetPointComponent(2, zAxis, 0) do2ds.Update() if fdr.GetOutput().GetFieldData().GetAbstractArray( "Some Text").GetValue(0) != "Test me": raise RuntimeError, 'Could not properly read string array "Some Text"' fd2ad = vtk.vtkFieldDataToAttributeDataFilter() fd2ad.SetInputConnection(do2ds.GetOutputPort()) fd2ad.SetInputFieldToDataObjectField() fd2ad.SetOutputAttributeDataToPointData() fd2ad.DefaultNormalizeOn() fd2ad.SetScalarComponent(0, scalar, 0) # construct pipeline for original population popSplatter = vtk.vtkGaussianSplatter() popSplatter.SetInputConnection(fd2ad.GetOutputPort()) popSplatter.SetSampleDimensions(50, 50, 50) popSplatter.SetRadius(0.05) popSplatter.ScalarWarpingOff() popSurface = vtk.vtkMarchingContourFilter() popSurface.SetInputConnection(popSplatter.GetOutputPort()) popSurface.SetValue(0, 0.01) popMapper = vtk.vtkPolyDataMapper() popMapper.SetInputConnection(popSurface.GetOutputPort()) popMapper.ScalarVisibilityOff() popActor = vtk.vtkActor() popActor.SetMapper(popMapper) popActor.GetProperty().SetOpacity(0.3) popActor.GetProperty().SetColor(.9, .9, .9) # construct pipeline for delinquent population lateSplatter = vtk.vtkGaussianSplatter() lateSplatter.SetInputConnection(fd2ad.GetOutputPort()) lateSplatter.SetSampleDimensions(50, 50, 50) lateSplatter.SetRadius(0.05) lateSplatter.SetScaleFactor(0.05) lateSurface = vtk.vtkMarchingContourFilter() lateSurface.SetInputConnection(lateSplatter.GetOutputPort()) lateSurface.SetValue(0, 0.01) lateMapper = vtk.vtkPolyDataMapper() lateMapper.SetInputConnection(lateSurface.GetOutputPort()) lateMapper.ScalarVisibilityOff() lateActor = vtk.vtkActor() lateActor.SetMapper(lateMapper) lateActor.GetProperty().SetColor(1.0, 0.0, 0.0) # create axes popSplatter.Update() bounds = popSplatter.GetOutput().GetBounds() axes = vtk.vtkAxes() axes.SetOrigin(bounds[0], bounds[2], bounds[4]) axes.SetScaleFactor(popSplatter.GetOutput().GetLength() / 5.0) axesTubes = vtk.vtkTubeFilter() axesTubes.SetInputConnection(axes.GetOutputPort()) axesTubes.SetRadius(axes.GetScaleFactor() / 25.0) axesTubes.SetNumberOfSides(6) axesMapper = vtk.vtkPolyDataMapper() axesMapper.SetInputConnection(axesTubes.GetOutputPort()) axesActor = vtk.vtkActor() axesActor.SetMapper(axesMapper) # label the axes XText = vtk.vtkVectorText() XText.SetText(xAxis) XTextMapper = vtk.vtkPolyDataMapper() XTextMapper.SetInputConnection(XText.GetOutputPort()) XActor = vtk.vtkFollower() XActor.SetMapper(XTextMapper) XActor.SetScale(0.02, .02, .02) XActor.SetPosition(0.35, -0.05, -0.05) XActor.GetProperty().SetColor(0, 0, 0) YText = vtk.vtkVectorText() YText.SetText(yAxis) YTextMapper = vtk.vtkPolyDataMapper() YTextMapper.SetInputConnection(YText.GetOutputPort()) YActor = vtk.vtkFollower() YActor.SetMapper(YTextMapper) YActor.SetScale(0.02, .02, .02) YActor.SetPosition(-0.05, 0.35, -0.05) YActor.GetProperty().SetColor(0, 0, 0) ZText = vtk.vtkVectorText() ZText.SetText(zAxis) ZTextMapper = vtk.vtkPolyDataMapper() ZTextMapper.SetInputConnection(ZText.GetOutputPort()) ZActor = vtk.vtkFollower() ZActor.SetMapper(ZTextMapper) ZActor.SetScale(0.02, .02, .02) ZActor.SetPosition(-0.05, -0.05, 0.35) ZActor.GetProperty().SetColor(0, 0, 0) # Graphics stuff # ren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) renWin.SetWindowName("vtk - Field.Data") # Add the actors to the renderer, set the background and size # ren.AddActor(axesActor) ren.AddActor(lateActor) ren.AddActor(XActor) ren.AddActor(YActor) ren.AddActor(ZActor) ren.AddActor(popActor) #it's last because its translucent) ren.SetBackground(1, 1, 1) renWin.SetSize(400, 400) camera = vtk.vtkCamera() camera.SetClippingRange(.274, 13.72) camera.SetFocalPoint(0.433816, 0.333131, 0.449) camera.SetPosition(-1.96987, 1.15145, 1.49053) camera.SetViewUp(0.378927, 0.911821, 0.158107) ren.SetActiveCamera(camera) XActor.SetCamera(camera) YActor.SetCamera(camera) ZActor.SetCamera(camera) # render and interact with data iRen = vtk.vtkRenderWindowInteractor() iRen.SetRenderWindow(renWin) renWin.Render() img_file = "financialField.png" vtk.test.Testing.compareImage( iRen.GetRenderWindow(), vtk.test.Testing.getAbsImagePath(img_file), threshold=25) vtk.test.Testing.interact()
def Add_MomActors(self,ren,renWin,iren,ASDdata,window): """Main wrapper to add the needed actors for visualization of the moments. Class that contains the data structures for creation of the glyphs or the visualization of the magnetic moments. It also has the capacity to create tessellations for the visualization of volume vendering. Args: ren: current renderer. renWin: current rendering window. iren: current interactor for the renderer. ASDdata: class where the data read from the ASD simulations is stored. window: QMainWindow object where the visualization is performed. Author ---------- Jonathan Chico """ import vtk import numpy as np ASDMomActors.timer_count=0 ASDMomActors.camera_pos=np.zeros(3,dtype=np.float32) ASDMomActors.camera_focal=np.zeros(3,dtype=np.float32) ASDMomActors.camera_yaw=0.0 ASDMomActors.camera_roll=0.0 ASDMomActors.camera_pitch=0.0 ASDMomActors.camera_azimuth=0.0 ASDMomActors.camera_elevation=0.0 ASDMomActors.kmc_disp=ASDdata.kmc_flag ASDMomActors.cluster_disp=ASDdata.cluster_flag ASDMomActors.glob_color=ASDdata.colors #----------------------------------------------------------------------- # Look up tables for colors #----------------------------------------------------------------------- # This is a diverging RWB color mapping based on the work of Kenneth # Moreland and with the vtk examples provided by Andrew Maclean if ASDdata.flag2D: ASDMomActors.lut = vtk.vtkLookupTable() num_colors = 256 ASDMomActors.lut.SetNumberOfTableValues(num_colors) ASDMomActors.transfer_func = vtk.vtkColorTransferFunction() ASDMomActors.transfer_func.SetColorSpaceToDiverging() ASDMomActors.transfer_func.AddRGBPoint(0, 0.230, 0.299, 0.754) ASDMomActors.transfer_func.AddRGBPoint(1, 0.706, 0.016, 0.150) for ii,ss in enumerate([float(xx)/float(num_colors) for xx in range(num_colors)]): cc = ASDMomActors.transfer_func.GetColor(ss) ASDMomActors.lut.SetTableValue(ii, cc[0], cc[1], cc[2], 1.0) ASDMomActors.lut.Build() else: ASDMomActors.lut = vtk.vtkLookupTable() num_colors = 256 ASDMomActors.lut.SetNumberOfTableValues(num_colors) ASDMomActors.transfer_func = vtk.vtkColorTransferFunction() ASDMomActors.transfer_func.SetColorSpaceToDiverging() ASDMomActors.transfer_func.AddRGBPoint(-0, 0.230, 0.299, 0.754) ASDMomActors.transfer_func.AddRGBPoint( 1, 0.706, 0.016, 0.150) for ii,ss in enumerate([float(xx)/float(num_colors) for xx in range(num_colors)]): cc = ASDMomActors.transfer_func.GetColor(ss) ASDMomActors.lut.SetTableValue(ii, cc[0], cc[1], cc[2], 1.0) ASDMomActors.lut.Build() #----------------------------------------------------------------------- # Data structures for the generation of the smooth grid #----------------------------------------------------------------------- # Passing the data from the full system to the PolyData ASDMomActors.src=vtk.vtkPolyData() ASDMomActors.src.SetPoints(ASDdata.coord) ASDMomActors.src.GetPointData().SetScalars(ASDdata.colors[2]) ASDMomActors.src.GetPointData().SetVectors(ASDdata.moments) scalar_range = ASDMomActors.src.GetScalarRange() #----------------------------------------------------------------------- # Finding useful geometrical information of the sample #----------------------------------------------------------------------- # Finding the middle of the sample # Also making sure that if the sample is 2D one has no problem with bounds # this is mostly useful if splatters are used (ASDMomActors.xmin,ASDMomActors.xmax,ASDMomActors.ymin,ASDMomActors.ymax,\ ASDMomActors.zmin,ASDMomActors.zmax)= ASDMomActors.src.GetBounds() if ASDMomActors.xmin==ASDMomActors.xmax: ASDMomActors.xmin=0.0 ASDMomActors.xmax=1.0 if ASDMomActors.ymin==ASDMomActors.ymax: ASDMomActors.ymin=0.0 ASDMomActors.ymax=1.0 if ASDMomActors.zmin==ASDMomActors.zmax: ASDMomActors.zmin=0.0 ASDMomActors.zmax=1.0 ASDMomActors.xmid = (ASDMomActors.xmin+ASDMomActors.xmax)*0.5 ASDMomActors.ymid = (ASDMomActors.ymin+ASDMomActors.ymax)*0.5 ASDMomActors.zmid = (ASDMomActors.zmin+ASDMomActors.zmax)*0.5 ASDMomActors.height=max(ASDMomActors.xmax,ASDMomActors.ymax,ASDMomActors.zmax)*1.75 self.dist_x=np.absolute(ASDMomActors.xmax-ASDMomActors.xmin) self.dist_y=np.absolute(ASDMomActors.ymax-ASDMomActors.ymin) self.dist_z=np.absolute(ASDMomActors.zmax-ASDMomActors.zmin) ASDMomActors.camera_pos[0]=ASDMomActors.xmid ASDMomActors.camera_pos[1]=ASDMomActors.ymid ASDMomActors.camera_pos[2]=ASDMomActors.height ASDMomActors.camera_focal[0]=ASDMomActors.xmid ASDMomActors.camera_focal[1]=ASDMomActors.ymid ASDMomActors.camera_focal[2]=ASDMomActors.zmid # The delaunay tessellation seems to be the best way to transform the point cloud # to a surface for volume rendering, the problem is that it is too slow for large # data sets, meaning that the best option is first to prune out the data to ensure # that one has a manageable number of data points over which to do the construction # surface reconstruction and splatter techniques also can be used to generate something # akin to the kind of surfaces we want. The issue is that they transform the data to a # regular mesh by default. And thus it is a problem for most kind of systems if ASDdata.flag2D: # Passing the data to generate a triangulation of the data ASDMomActors.MagDensMethod = vtk.vtkDelaunay2D() ASDMomActors.MagDensMethod.SetInputData(ASDMomActors.src) ASDMomActors.MagDensMethod.BoundingTriangulationOff() ASDMomActors.MagDensMethod.SetTolerance(0.005) # Time the execution of the delaunay tessellation SM_timer = vtk.vtkExecutionTimer() SM_timer.SetFilter(ASDMomActors.MagDensMethod) ASDMomActors.MagDensMethod.Update() SM = SM_timer.GetElapsedWallClockTime() print ("2D Delaunay:", SM) # Creating the mapper for the smooth surfaces ASDMomActors.MagDensMap = vtk.vtkDataSetMapper() ASDMomActors.MagDensMap.SetScalarRange(scalar_range) ASDMomActors.MagDensMap.SetInputConnection(ASDMomActors.MagDensMethod.GetOutputPort()) ASDMomActors.MagDensMap.SetLookupTable(ASDMomActors.lut) ASDMomActors.MagDensMap.SetColorModeToMapScalars() ASDMomActors.MagDensMap.Update() # Creating the actor for the smooth surfaces ASDMomActors.MagDensActor = vtk.vtkLODActor() ASDMomActors.MagDensActor.SetMapper(ASDMomActors.MagDensMap) ASDMomActors.MagDensActor.GetProperty().SetOpacity(0.75) ASDMomActors.MagDensActor.GetProperty().EdgeVisibilityOff() if window.DensBox.isChecked(): ASDMomActors.MagDensActor.VisibilityOn() else: ASDMomActors.MagDensActor.VisibilityOff() else: #------------------------------------------------------------------- # Setting the parameters for the visualization of 3D structures with # splatters #------------------------------------------------------------------- ASDMomActors.MagDensMethod = vtk.vtkGaussianSplatter() ASDMomActors.MagDensMethod.SetInputData(ASDMomActors.src) #------------------------------------------------------------------- # Options for the Gaussian splatter. These determine the quality of the # rendering, increasing the radius smoothens out the volume but performance # decreases rapidly #------------------------------------------------------------------- dist=(np.asarray(ASDMomActors.src.GetPoint(0))-np.asarray(ASDMomActors.src.GetPoint(1))) norm=np.sqrt(dist.dot(dist)) if norm<1: rad_fac=0.040 else: rad_fac=0.40 ASDMomActors.MagDensMethod.SetRadius(rad_fac) ASDMomActors.MagDensMethod.ScalarWarpingOn() #------------------------------------------------------------------- # The exponent factor determines how fast the gaussian splatter decay # they again can be used to improve quality at the sake of rendering time #------------------------------------------------------------------- ASDMomActors.MagDensMethod.SetExponentFactor(-10) ASDMomActors.MagDensMethod.NormalWarpingOn() ASDMomActors.MagDensMethod.SetEccentricity(10) #------------------------------------------------------------------- # The Null value can be used to try to eliminate contributions not belonging # to the actual sample #------------------------------------------------------------------- ASDMomActors.MagDensMethod.SetNullValue(-10) #------------------------------------------------------------------- # Set the actual size of the rendering model #------------------------------------------------------------------- ASDMomActors.MagDensMethod.SetModelBounds(ASDMomActors.xmin,ASDMomActors.xmax,\ ASDMomActors.ymin,ASDMomActors.ymax,ASDMomActors.zmin,ASDMomActors.zmax) # This should get rid of the problems when trying to map very thin structures in 2D if self.dist_x==min(self.dist_x,self.dist_y,self.dist_z) and self.dist_x<3: ASDMomActors.MagDensMethod.SetSampleDimensions(3,int(ASDMomActors.ymax),int(ASDMomActors.zmax)) elif self.dist_y==min(self.dist_x,self.dist_y,self.dist_z) and self.dist_y<3: ASDMomActors.MagDensMethod.SetSampleDimensions(int(ASDMomActors.xmax),3,int(ASDMomActors.zmax)) elif self.dist_z==min(self.dist_x,self.dist_y,self.dist_z) and self.dist_z<3: ASDMomActors.MagDensMethod.SetSampleDimensions(int(ASDMomActors.xmax),int(ASDMomActors.ymax),3) # Timming for the execution of the volume creation SP_timer = vtk.vtkExecutionTimer() SP_timer.SetFilter(ASDMomActors.MagDensMethod) ASDMomActors.MagDensMethod.Update() SP = SP_timer.GetElapsedWallClockTime() print ("3D vtkGaussianSplatter Method:", SP) # Scalar opacities funcOpacityScalar = vtk.vtkPiecewiseFunction() funcOpacityScalar.AddPoint(-1.00,0.00) funcOpacityScalar.AddPoint( 0.00,0.05) funcOpacityScalar.AddPoint( 0.50,0.50) funcOpacityScalar.AddPoint( 0.75,1.00) # Gradient opacities volumeGradientOpacity = vtk.vtkPiecewiseFunction() volumeGradientOpacity.AddPoint(0.000,0.0) volumeGradientOpacity.AddPoint(0.001,1.0) volumeGradientOpacity.AddPoint(1.000,1.0) # Volume properties ASDMomActors.volumeProperty = vtk.vtkVolumeProperty() ASDMomActors.volumeProperty.SetColor(ASDMomActors.transfer_func) ASDMomActors.volumeProperty.SetInterpolationTypeToLinear() ASDMomActors.volumeProperty.SetAmbient(0.6) ASDMomActors.volumeProperty.SetDiffuse(0.6) ASDMomActors.volumeProperty.SetSpecular(0.1) ASDMomActors.volumeProperty.SetGradientOpacity(volumeGradientOpacity) ASDMomActors.volumeProperty.SetScalarOpacity(funcOpacityScalar) # Volume Mapper ASDMomActors.MagDensMap = vtk.vtkSmartVolumeMapper() ASDMomActors.MagDensMap.SetInputConnection(ASDMomActors.MagDensMethod.GetOutputPort()) # Volume Actor ASDMomActors.MagDensActor = vtk.vtkVolume() ASDMomActors.MagDensActor.SetMapper(ASDMomActors.MagDensMap) ASDMomActors.MagDensActor.SetProperty(self.volumeProperty) if window.DensBox.isChecked(): ASDMomActors.MagDensActor.VisibilityOn() else: ASDMomActors.MagDensActor.VisibilityOff() #----------------------------------------------------------------------- # Data structures for the spins #----------------------------------------------------------------------- # Passing the data from the full system to the PolyData ASDMomActors.src_spins=vtk.vtkPolyData() ASDMomActors.src_spins.SetPoints(ASDdata.coord) ASDMomActors.src_spins.GetPointData().SetScalars(ASDdata.colors[2]) ASDMomActors.src_spins.GetPointData().SetVectors(ASDdata.moments) scalar_range_spins = ASDMomActors.src_spins.GetScalarRange() #----------------------------------------------------------------------- # Data structures for the contours #----------------------------------------------------------------------- # Define the contour filters contours = vtk.vtkContourFilter() contours.SetInputConnection(ASDMomActors.MagDensMethod.GetOutputPort()) # This generates the contours, it will do 5 between the -1 and 0.5 range cont_num=5 range_cont=(-1,0.5) contours.GenerateValues(cont_num,range_cont) # Map the contours to graphical primitives contMapper = vtk.vtkPolyDataMapper() contMapper.SetInputConnection(contours.GetOutputPort()) contMapper.SetScalarVisibility(False) # colored contours contMapper.SetScalarRange(scalar_range) # Create an actor for the contours ASDMomActors.contActor = vtk.vtkLODActor() ASDMomActors.contActor.SetMapper(contMapper) ASDMomActors.contActor.GetProperty().SetColor(0, 0, 0) ASDMomActors.contActor.GetProperty().SetLineWidth(1.0) ASDMomActors.contActor.VisibilityOff() #----------------------------------------------------------------------- # Setting information of the directions #----------------------------------------------------------------------- # Create vectors arrow = vtk.vtkArrowSource() arrow.SetTipRadius(0.20) arrow.SetShaftRadius(0.10) arrow.SetTipResolution(20) arrow.SetShaftResolution(20) # Create the mapper for the spins arrowMapper = vtk.vtkGlyph3DMapper() arrowMapper.SetSourceConnection(arrow.GetOutputPort()) arrowMapper.SetInputData(ASDMomActors.src) arrowMapper.SetScaleFactor(0.50) arrowMapper.SetScalarVisibility(False) arrowMapper.SetScaleModeToNoDataScaling() arrowMapper.Update() # Define the vector actor for the spins ASDMomActors.vector = vtk.vtkLODActor() ASDMomActors.vector.SetMapper(arrowMapper) ASDMomActors.vector.GetProperty().SetSpecular(0.3) ASDMomActors.vector.GetProperty().SetSpecularPower(60) ASDMomActors.vector.GetProperty().SetAmbient(0.2) ASDMomActors.vector.GetProperty().SetDiffuse(0.8) ASDMomActors.vector.GetProperty().SetColor(0, 0, 0) ASDMomActors.vector.VisibilityOff() #----------------------------------------------------------------------- # Setting information of the spins #----------------------------------------------------------------------- # Create vectors ASDMomActors.spinarrow = vtk.vtkArrowSource() ASDMomActors.spinarrow.SetTipRadius(0.20) ASDMomActors.spinarrow.SetShaftRadius(0.10) ASDMomActors.spinarrow.SetTipResolution(20) ASDMomActors.spinarrow.SetShaftResolution(20) # Create the mapper for the spins ASDMomActors.SpinMapper = vtk.vtkGlyph3DMapper() ASDMomActors.SpinMapper.SetSourceConnection(ASDMomActors.spinarrow.GetOutputPort()) ASDMomActors.SpinMapper.SetInputData(ASDMomActors.src_spins) ASDMomActors.SpinMapper.SetScalarRange(scalar_range_spins) ASDMomActors.SpinMapper.SetScaleFactor(0.50) ASDMomActors.SpinMapper.SetScaleModeToNoDataScaling() ASDMomActors.SpinMapper.SetLookupTable(self.lut) ASDMomActors.SpinMapper.SetColorModeToMapScalars() ASDMomActors.SpinMapper.Update() # Define the vector actor for the spins ASDMomActors.Spins = vtk.vtkLODActor() ASDMomActors.Spins.SetMapper(ASDMomActors.SpinMapper) ASDMomActors.Spins.GetProperty().SetSpecular(0.3) ASDMomActors.Spins.GetProperty().SetSpecularPower(60) ASDMomActors.Spins.GetProperty().SetAmbient(0.2) ASDMomActors.Spins.GetProperty().SetDiffuse(0.8) if window.SpinsBox.isChecked(): ASDMomActors.Spins.VisibilityOn() else: ASDMomActors.Spins.VisibilityOff() if (ASDdata.kmc_flag): #------------------------------------------------------------------- # Setting data structures for the KMC particle visualization #------------------------------------------------------------------- ASDMomActors.KMC_src=vtk.vtkPolyData() ASDMomActors.KMC_src.SetPoints(ASDdata.coord_KMC) # Atom sphere KMC_part = vtk.vtkSphereSource() KMC_part.SetRadius(1.75) KMC_part.SetThetaResolution(40) KMC_part.SetPhiResolution(40) # Atom glyph KMC_part_mapper = vtk.vtkGlyph3DMapper() KMC_part_mapper.SetInputData(ASDMomActors.KMC_src) KMC_part_mapper.SetSourceConnection(KMC_part.GetOutputPort()) KMC_part_mapper.SetScaleFactor(0.5) KMC_part_mapper.ClampingOn() KMC_part_mapper.SetScaleModeToNoDataScaling() KMC_part_mapper.SetColorModeToMapScalars() KMC_part_mapper.Update() # Atoms actors ASDMomActors.KMC_part_actor = vtk.vtkLODActor() ASDMomActors.KMC_part_actor.SetMapper(KMC_part_mapper) ASDMomActors.KMC_part_actor.GetProperty().SetOpacity(0.9) ASDMomActors.KMC_part_actor.GetProperty().SetColor(0.0, 0.0, 1.0) ASDMomActors.KMC_part_actor.GetProperty().EdgeVisibilityOn() ASDMomActors.KMC_part_actor.GetProperty().SetEdgeColor(0,0,0) #----------------------------------------------------------------------- # Setting information of the renderer #----------------------------------------------------------------------- # Define the renderer # Add the actors to the scene if ASDdata.flag2D: ren.AddActor(ASDMomActors.MagDensActor) else: ren.AddViewProp(ASDMomActors.MagDensActor) ren.AddActor(ASDMomActors.Spins) ren.AddActor(ASDMomActors.vector) ren.AddActor(ASDMomActors.contActor) #If the KMC particles are present add them to the renderer if ASDdata.kmc_flag: ren.AddActor(ASDMomActors.KMC_part_actor) # Defining the camera directions ren.GetActiveCamera().Azimuth(ASDMomActors.camera_azimuth) ren.GetActiveCamera().Elevation(ASDMomActors.camera_elevation) ren.GetActiveCamera().Yaw(ASDMomActors.camera_yaw) ren.GetActiveCamera().Roll(ASDMomActors.camera_roll) ren.GetActiveCamera().Pitch(ASDMomActors.camera_pitch) ren.GetActiveCamera().SetFocalPoint(ASDMomActors.camera_focal) ren.GetActiveCamera().SetPosition(ASDMomActors.camera_pos) ren.GetActiveCamera().SetViewUp(0,1,0) #----------------------------------------------------------------------- # Start the renderer #----------------------------------------------------------------------- iren.Start() renWin.Render() return;
def testFinancialField(self): """ Demonstrate the use and manipulation of fields and use of vtkProgrammableDataObjectSource. This creates fields the hard way (as compared to reading a vtk field file), but shows you how to interface to your own raw data. The image should be the same as financialField.tcl """ xAxis = "INTEREST_RATE" yAxis = "MONTHLY_PAYMENT" zAxis = "MONTHLY_INCOME" scalar = "TIME_LATE" # Parse an ascii file and manually create a field. Then construct a # dataset from the field. dos = vtk.vtkProgrammableDataObjectSource() def parseFile(): f = open(VTK_DATA_ROOT + "/Data/financial.txt", "r") line = f.readline().split() # From the size calculate the number of lines. numPts = int(line[1]) numLines = (numPts - 1) / 8 + 1 # create the data object field = vtk.vtkFieldData() field.AllocateArrays(4) # read TIME_LATE - dependent variable while True: line = f.readline().split() if len(line) > 0: break timeLate = vtk.vtkFloatArray() timeLate.SetName(line[0]) for i in range(0, numLines): line = f.readline().split() for j in line: timeLate.InsertNextValue(float(j)) field.AddArray(timeLate) # MONTHLY_PAYMENT - independent variable while True: line = f.readline().split() if len(line) > 0: break monthlyPayment = vtk.vtkFloatArray() monthlyPayment.SetName(line[0]) for i in range(0, numLines): line = f.readline().split() for j in line: monthlyPayment.InsertNextValue(float(j)) field.AddArray(monthlyPayment) # UNPAID_PRINCIPLE - skip while True: line = f.readline().split() if len(line) > 0: break for i in range(0, numLines): line = f.readline() # LOAN_AMOUNT - skip while True: line = f.readline().split() if len(line) > 0: break for i in range(0, numLines): line = f.readline() # INTEREST_RATE - independent variable while True: line = f.readline().split() if len(line) > 0: break interestRate = vtk.vtkFloatArray() interestRate.SetName(line[0]) for i in range(0, numLines): line = f.readline().split() for j in line: interestRate.InsertNextValue(float(j)) field.AddArray(interestRate) # MONTHLY_INCOME - independent variable while True: line = f.readline().split() if len(line) > 0: break monthlyIncome = vtk.vtkFloatArray() monthlyIncome.SetName(line[0]) for i in range(0, numLines): line = f.readline().split() for j in line: monthlyIncome.InsertNextValue(float(j)) field.AddArray(monthlyIncome) dos.GetOutput().SetFieldData(field) dos.SetExecuteMethod(parseFile) # Create the dataset do2ds = vtk.vtkDataObjectToDataSetFilter() do2ds.SetInputConnection(dos.GetOutputPort()) do2ds.SetDataSetTypeToPolyData() #format: component#, arrayname, arraycomp, minArrayId, maxArrayId, normalize do2ds.DefaultNormalizeOn() do2ds.SetPointComponent(0, xAxis, 0) do2ds.SetPointComponent(1, yAxis, 0) do2ds.SetPointComponent(2, zAxis, 0) do2ds.Update() rf = vtk.vtkRearrangeFields() rf.SetInputConnection(do2ds.GetOutputPort()) rf.AddOperation("MOVE", scalar, "DATA_OBJECT", "POINT_DATA") rf.RemoveOperation("MOVE", scalar, "DATA_OBJECT", "POINT_DATA") rf.AddOperation("MOVE", scalar, "DATA_OBJECT", "POINT_DATA") rf.RemoveAllOperations() rf.AddOperation("MOVE", scalar, "DATA_OBJECT", "POINT_DATA") rf.Update() max = rf.GetOutput().GetPointData().GetArray(scalar).GetRange(0)[1] calc = vtk.vtkArrayCalculator() calc.SetInputConnection(rf.GetOutputPort()) calc.SetAttributeTypeToPointData() calc.SetFunction("s / %f" % max) calc.AddScalarVariable("s", scalar, 0) calc.SetResultArrayName("resArray") aa = vtk.vtkAssignAttribute() aa.SetInputConnection(calc.GetOutputPort()) aa.Assign("resArray", "SCALARS", "POINT_DATA") aa.Update() rf2 = vtk.vtkRearrangeFields() rf2.SetInputConnection(aa.GetOutputPort()) rf2.AddOperation("COPY", "SCALARS", "POINT_DATA", "DATA_OBJECT") # construct pipeline for original population popSplatter = vtk.vtkGaussianSplatter() popSplatter.SetInputConnection(rf2.GetOutputPort()) popSplatter.SetSampleDimensions(50, 50, 50) popSplatter.SetRadius(0.05) popSplatter.ScalarWarpingOff() popSurface = vtk.vtkContourFilter() popSurface.SetInputConnection(popSplatter.GetOutputPort()) popSurface.SetValue(0, 0.01) popMapper = vtk.vtkPolyDataMapper() popMapper.SetInputConnection(popSurface.GetOutputPort()) popMapper.ScalarVisibilityOff() popMapper.ImmediateModeRenderingOn() popActor = vtk.vtkActor() popActor.SetMapper(popMapper) popActor.GetProperty().SetOpacity(0.3) popActor.GetProperty().SetColor(.9, .9, .9) # construct pipeline for delinquent population lateSplatter = vtk.vtkGaussianSplatter() lateSplatter.SetInputConnection(aa.GetOutputPort()) lateSplatter.SetSampleDimensions(50, 50, 50) lateSplatter.SetRadius(0.05) lateSplatter.SetScaleFactor(0.05) lateSurface = vtk.vtkContourFilter() lateSurface.SetInputConnection(lateSplatter.GetOutputPort()) lateSurface.SetValue(0, 0.01) lateMapper = vtk.vtkPolyDataMapper() lateMapper.SetInputConnection(lateSurface.GetOutputPort()) lateMapper.ScalarVisibilityOff() lateActor = vtk.vtkActor() lateActor.SetMapper(lateMapper) lateActor.GetProperty().SetColor(1.0, 0.0, 0.0) # create axes popSplatter.Update() bounds = popSplatter.GetOutput().GetBounds() axes = vtk.vtkAxes() axes.SetOrigin(bounds[0], bounds[2], bounds[4]) axes.SetScaleFactor(popSplatter.GetOutput().GetLength() / 5.0) axesTubes = vtk.vtkTubeFilter() axesTubes.SetInputConnection(axes.GetOutputPort()) axesTubes.SetRadius(axes.GetScaleFactor() / 25.0) axesTubes.SetNumberOfSides(6) axesMapper = vtk.vtkPolyDataMapper() axesMapper.SetInputConnection(axesTubes.GetOutputPort()) axesActor = vtk.vtkActor() axesActor.SetMapper(axesMapper) # label the axes XText = vtk.vtkVectorText() XText.SetText(xAxis) XTextMapper = vtk.vtkPolyDataMapper() XTextMapper.SetInputConnection(XText.GetOutputPort()) XActor = vtk.vtkFollower() XActor.SetMapper(XTextMapper) XActor.SetScale(0.02, .02, .02) XActor.SetPosition(0.35, -0.05, -0.05) XActor.GetProperty().SetColor(0, 0, 0) YText = vtk.vtkVectorText() YText.SetText(yAxis) YTextMapper = vtk.vtkPolyDataMapper() YTextMapper.SetInputConnection(YText.GetOutputPort()) YActor = vtk.vtkFollower() YActor.SetMapper(YTextMapper) YActor.SetScale(0.02, .02, .02) YActor.SetPosition(-0.05, 0.35, -0.05) YActor.GetProperty().SetColor(0, 0, 0) ZText = vtk.vtkVectorText() ZText.SetText(zAxis) ZTextMapper = vtk.vtkPolyDataMapper() ZTextMapper.SetInputConnection(ZText.GetOutputPort()) ZActor = vtk.vtkFollower() ZActor.SetMapper(ZTextMapper) ZActor.SetScale(0.02, .02, .02) ZActor.SetPosition(-0.05, -0.05, 0.35) ZActor.GetProperty().SetColor(0, 0, 0) # Graphics stuff # ren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) renWin.SetWindowName("vtk(-, Field.Data") renWin.SetSize(300, 300) # Add the actors to the renderer, set the background and size # ren.AddActor(axesActor) ren.AddActor(lateActor) ren.AddActor(XActor) ren.AddActor(YActor) ren.AddActor(ZActor) ren.AddActor(popActor) #it's last because its translucent) ren.SetBackground(1, 1, 1) camera = vtk.vtkCamera() camera.SetClippingRange(.274, 13.72) camera.SetFocalPoint(0.433816, 0.333131, 0.449) camera.SetPosition(-1.96987, 1.15145, 1.49053) camera.SetViewUp(0.378927, 0.911821, 0.158107) ren.SetActiveCamera(camera) XActor.SetCamera(camera) YActor.SetCamera(camera) ZActor.SetCamera(camera) # render and interact with data iRen = vtk.vtkRenderWindowInteractor() iRen.SetRenderWindow(renWin) renWin.Render() img_file = "financialField3.png" vtk.test.Testing.compareImage( iRen.GetRenderWindow(), vtk.test.Testing.getAbsImagePath(img_file), threshold=25) vtk.test.Testing.interact()
def main(): colors = vtk.vtkNamedColors() colors.SetColor("PopColor", [230, 230, 230, 255]) fileName = get_program_parameters() keys = [ 'NUMBER_POINTS', 'MONTHLY_PAYMENT', 'INTEREST_RATE', 'LOAN_AMOUNT', 'TIME_LATE' ] # Read in the data and make an unstructured data set. dataSet = make_dataset(fileName, keys) # Construct the pipeline for the original population. popSplatter = vtk.vtkGaussianSplatter() popSplatter.SetInputData(dataSet) popSplatter.SetSampleDimensions(100, 100, 100) popSplatter.SetRadius(0.05) popSplatter.ScalarWarpingOff() popSurface = vtk.vtkContourFilter() popSurface.SetInputConnection(popSplatter.GetOutputPort()) popSurface.SetValue(0, 0.01) popMapper = vtk.vtkPolyDataMapper() popMapper.SetInputConnection(popSurface.GetOutputPort()) popMapper.ScalarVisibilityOff() popActor = vtk.vtkActor() popActor.SetMapper(popMapper) popActor.GetProperty().SetOpacity(0.3) popActor.GetProperty().SetColor(colors.GetColor3d("PopColor")) # Construct the pipeline for the delinquent population. lateSplatter = vtk.vtkGaussianSplatter() lateSplatter.SetInputData(dataSet) lateSplatter.SetSampleDimensions(50, 50, 50) lateSplatter.SetRadius(0.05) lateSplatter.SetScaleFactor(0.005) lateSurface = vtk.vtkContourFilter() lateSurface.SetInputConnection(lateSplatter.GetOutputPort()) lateSurface.SetValue(0, 0.01) lateMapper = vtk.vtkPolyDataMapper() lateMapper.SetInputConnection(lateSurface.GetOutputPort()) lateMapper.ScalarVisibilityOff() lateActor = vtk.vtkActor() lateActor.SetMapper(lateMapper) lateActor.GetProperty().SetColor(colors.GetColor3d("Red")) # Create axes. popSplatter.Update() bounds = popSplatter.GetOutput().GetBounds() axes = vtk.vtkAxes() axes.SetOrigin(bounds[0], bounds[2], bounds[4]) axes.SetScaleFactor(popSplatter.GetOutput().GetLength() / 5) axesTubes = vtk.vtkTubeFilter() axesTubes.SetInputConnection(axes.GetOutputPort()) axesTubes.SetRadius(axes.GetScaleFactor() / 25.0) axesTubes.SetNumberOfSides(6) axesMapper = vtk.vtkPolyDataMapper() axesMapper.SetInputConnection(axesTubes.GetOutputPort()) axesActor = vtk.vtkActor() axesActor.SetMapper(axesMapper) # Graphics stuff. renderer = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(renderer) interactor = vtk.vtkRenderWindowInteractor() interactor.SetRenderWindow(renWin) # Set up the renderer. renderer.AddActor(lateActor) renderer.AddActor(axesActor) renderer.AddActor(popActor) renderer.SetBackground(colors.GetColor3d("Wheat")) renWin.SetSize(640, 480) renderer.ResetCamera() renderer.GetActiveCamera().Dolly(1.3) renderer.ResetCameraClippingRange() # Interact with the data. renWin.Render() interactor.Start()
def _render_blurry_particles(self, particles_dataset): particles_per_species = dict((k, vtk.vtkPoints()) for k in self._species_idmap.iterkeys()) scaling = self.settings.scaling position_idx = particles_dataset.dtype.names.index('position') species_id_idx = particles_dataset.dtype.names.index('species_id') for p in particles_dataset: pos = p[position_idx] display_species_id = self._species_idmap.get(p[species_id_idx]) if display_species_id is None: continue particles_per_species[display_species_id].InsertNextPoint( pos * scaling / self._world_size) nx = ny = nz = self.settings.fluorimetry_axial_voxel_number for display_species_id, points in particles_per_species.iteritems(): poly_data = vtk.vtkPolyData() poly_data.SetPoints(points) poly_data.ComputeBounds() pattr = self._pattrs[display_species_id] # Calc standard deviation of gauss distribution function wave_length = pattr['fluorimetry_wave_length'] sigma = scaling * 0.5 * wave_length / self._world_size # Create guassian splatter gs = vtk.vtkGaussianSplatter() gs.SetInput(poly_data) gs.SetSampleDimensions(nx, ny, nz) gs.SetRadius(sigma) gs.SetExponentFactor(-.5) gs.ScalarWarpingOff() gs.SetModelBounds([-sigma, scaling + sigma] * 3) gs.SetAccumulationModeToMax() # Create filter for volume rendering filter = vtk.vtkImageShiftScale() # Scales to unsigned char filter.SetScale(255. * pattr['fluorimetry_brightness']) filter.ClampOverflowOn() filter.SetOutputScalarTypeToUnsignedChar() filter.SetInputConnection(gs.GetOutputPort()) mapper = vtk.vtkFixedPointVolumeRayCastMapper() mapper.SetInputConnection(filter.GetOutputPort()) volume = vtk.vtkVolume() property = volume.GetProperty() # vtk.vtkVolumeProperty() color = pattr['fluorimetry_luminescence_color'] color_tfunc = vtk.vtkColorTransferFunction() color_tfunc.AddRGBPoint(0, color[0], color[1], color[2]) property.SetColor(color_tfunc) opacity_tfunc = vtk.vtkPiecewiseFunction() opacity_tfunc.AddPoint(0, 0.0) opacity_tfunc.AddPoint(255., 1.0) property.SetScalarOpacity(opacity_tfunc) property.SetInterpolationTypeToLinear() if self.settings.fluorimetry_shadow_display: property.ShadeOn() else: property.ShadeOff() volume.SetMapper(mapper) self.renderer.AddVolume(volume)
def main(): ifn = get_program_parameters() colors = vtk.vtkNamedColors() reader = vtk.vtkDataObjectReader() reader.SetFileName(ifn) size = 3187 # maximum number possible xAxis = "INTEREST_RATE" yAxis = "MONTHLY_PAYMENT" zAxis = "MONTHLY_INCOME" scalar = "TIME_LATE" # Extract data from field as a polydata (just points), then extract scalars. do2ds = vtk.vtkDataObjectToDataSetFilter() do2ds.SetInputConnection(reader.GetOutputPort()) do2ds.SetDataSetTypeToPolyData() # format: component#, arrayname, arraycomp, minArrayId, maxArrayId, normalize do2ds.DefaultNormalizeOn() do2ds.SetPointComponent(0, xAxis, 0) do2ds.SetPointComponent(1, yAxis, 0, 0, size, 1) do2ds.SetPointComponent(2, zAxis, 0) do2ds.Update() fd2ad = vtk.vtkFieldDataToAttributeDataFilter() fd2ad.SetInputConnection(do2ds.GetOutputPort()) fd2ad.SetInputFieldToDataObjectField() fd2ad.SetOutputAttributeDataToPointData() fd2ad.DefaultNormalizeOn() fd2ad.SetScalarComponent(0, scalar, 0) # Construct the pipeline for the original population. popSplatter = vtk.vtkGaussianSplatter() popSplatter.SetInputConnection(fd2ad.GetOutputPort()) popSplatter.SetSampleDimensions(150, 150, 150) popSplatter.SetRadius(0.05) popSplatter.ScalarWarpingOff() popSurface = vtk.vtkMarchingContourFilter() popSurface.SetInputConnection(popSplatter.GetOutputPort()) popSurface.SetValue(0, 0.01) popMapper = vtk.vtkPolyDataMapper() popMapper.SetInputConnection(popSurface.GetOutputPort()) popMapper.ScalarVisibilityOff() popActor = vtk.vtkActor() popActor.SetMapper(popMapper) popActor.GetProperty().SetOpacity(0.3) popActor.GetProperty().SetColor(colors.GetColor3d("Gold")) # Construct the pipeline for the delinquent population. lateSplatter = vtk.vtkGaussianSplatter() lateSplatter.SetInputConnection(fd2ad.GetOutputPort()) lateSplatter.SetSampleDimensions(150, 150, 150) lateSplatter.SetRadius(0.05) lateSplatter.SetScaleFactor(0.05) lateSurface = vtk.vtkMarchingContourFilter() lateSurface.SetInputConnection(lateSplatter.GetOutputPort()) lateSurface.SetValue(0, 0.01) lateMapper = vtk.vtkPolyDataMapper() lateMapper.SetInputConnection(lateSurface.GetOutputPort()) lateMapper.ScalarVisibilityOff() lateActor = vtk.vtkActor() lateActor.SetMapper(lateMapper) lateActor.GetProperty().SetColor(colors.GetColor3d("Tomato")) # Create the axes. popSplatter.Update() bounds = popSplatter.GetOutput().GetBounds() axes = vtk.vtkAxes() axes.SetOrigin(bounds[0], bounds[2], bounds[4]) axes.SetScaleFactor(popSplatter.GetOutput().GetLength() / 5.0) axesTubes = vtk.vtkTubeFilter() axesTubes.SetInputConnection(axes.GetOutputPort()) axesTubes.SetRadius(axes.GetScaleFactor() / 25.0) axesTubes.SetNumberOfSides(6) axesMapper = vtk.vtkPolyDataMapper() axesMapper.SetInputConnection(axesTubes.GetOutputPort()) axesActor = vtk.vtkActor() axesActor.SetMapper(axesMapper) # Label the axes. XText = vtk.vtkVectorText() XText.SetText(xAxis) XTextMapper = vtk.vtkPolyDataMapper() XTextMapper.SetInputConnection(XText.GetOutputPort()) XActor = vtk.vtkFollower() XActor.SetMapper(XTextMapper) XActor.SetScale(0.02, .02, .02) XActor.SetPosition(0.35, -0.05, -0.05) XActor.GetProperty().SetColor(0, 0, 0) YText = vtk.vtkVectorText() YText.SetText(yAxis) YTextMapper = vtk.vtkPolyDataMapper() YTextMapper.SetInputConnection(YText.GetOutputPort()) YActor = vtk.vtkFollower() YActor.SetMapper(YTextMapper) YActor.SetScale(0.02, .02, .02) YActor.SetPosition(-0.05, 0.35, -0.05) YActor.GetProperty().SetColor(0, 0, 0) ZText = vtk.vtkVectorText() ZText.SetText(zAxis) ZTextMapper = vtk.vtkPolyDataMapper() ZTextMapper.SetInputConnection(ZText.GetOutputPort()) ZActor = vtk.vtkFollower() ZActor.SetMapper(ZTextMapper) ZActor.SetScale(0.02, .02, .02) ZActor.SetPosition(-0.05, -0.05, 0.35) ZActor.GetProperty().SetColor(0, 0, 0) # Graphics stuff. renderer = vtk.vtkRenderer() renderWindow = vtk.vtkRenderWindow() renderWindow.AddRenderer(renderer) renderWindow.SetWindowName("vtk - Field.Data") # Add the actors to the renderer, set the background and size. renderer.AddActor(axesActor) renderer.AddActor(lateActor) renderer.AddActor(XActor) renderer.AddActor(YActor) renderer.AddActor(ZActor) renderer.AddActor(popActor) renderer.SetBackground(colors.GetColor3d("SlateGray")) renderWindow.SetSize(650, 480) camera = vtk.vtkCamera() camera.SetClippingRange(.274, 13.72) camera.SetFocalPoint(0.433816, 0.333131, 0.449) camera.SetPosition(-1.96987, 1.15145, 1.49053) camera.SetViewUp(0.378927, 0.911821, 0.158107) renderer.SetActiveCamera(camera) XActor.SetCamera(camera) YActor.SetCamera(camera) ZActor.SetCamera(camera) # Render and interact with the data. interactor = vtk.vtkRenderWindowInteractor() interactor.SetRenderWindow(renderWindow) renderWindow.Render() interactor.Start()
def dualSurfaceRendering(image1, image2): ren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) renWin.PolygonSmoothingOn() renWin.SetSize(400, 400) # create a renderwindowinteractor iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) # skinMesh = createMesh(image1,(int)(image1.GetScalarRange()[0]),(int)(image1.GetScalarRange()[1]-1)) skinMesh = createMesh(image1, 0, 255) boneMesh = createThresholdMesh(image2, 0, 255) ########################################################## # polydata=vtk.vtkPolyData() # polydata.SetPoints(boneMesh.GetPoints()) splatter = vtk.vtkGaussianSplatter() splatter.SetInputData(boneMesh) splatter.SetRadius(0.02) surface = vtk.vtkContourFilter() surface.SetInputConnection(splatter.GetOutputPort()) surface.SetValue(0, 0.01) # # Convert the image to a polydata # imageDataGeometryFilter = vtk.vtkImageDataGeometryFilter() # imageDataGeometryFilter.SetInputData(image2) # imageDataGeometryFilter.Update() mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(surface.GetOutputPort()) actor = vtk.vtkActor() actor.SetMapper(mapper) # actor.GetProperty().SetPointSize(0.01) ############################################################# # sigmoidMesh = createThresholdMesh(sigmoid_image,0,1) # boneMesh = createThresholdMesh(image1,(int)(image1.GetScalarRange()[1]-1), (int)(image1.GetScalarRange()[1])) skinMapper = vtk.vtkPolyDataMapper() skinMapper.SetInputData(skinMesh) skinMapper.ScalarVisibilityOff() skinActor = vtk.vtkActor() skinActor.SetMapper(skinMapper) skinActor.GetProperty().SetColor(1.0, 1.0, 1.0) skinActor.GetProperty().SetOpacity(1.0) skinActor.GetProperty().SetAmbient(0.1) skinActor.GetProperty().SetDiffuse(0.7) skinActor.GetProperty().SetSpecular(0.1) boneMapper = vtk.vtkPolyDataMapper() boneMapper.SetInputData(boneMesh) boneMapper.ScalarVisibilityOff() boneActor = vtk.vtkActor() boneActor.SetMapper(boneMapper) boneActor.GetProperty().SetColor(1.0, 0.0, 0.0) boneActor.GetProperty().SetAmbient(0.2) boneActor.GetProperty().SetDiffuse(0.7) boneActor.GetProperty().SetSpecular(0.2) boneActor.GetProperty().SetOpacity(1.0) # boneActor.GetProperty().SetPointSize(100) # sigmoidMapper = vtk.vtkPolyDataMapper() # sigmoidMapper.SetInputData(sigmoidMesh) # sigmoidMapper.ScalarVisibilityOff() # # sigmoidActor = vtk.vtkActor() # sigmoidActor.SetMapper(sigmoidMapper) # sigmoidActor.GetProperty().SetColor(0.0,1.0,0.0) # sigmoidActor.GetProperty().SetAmbient(0.2) # sigmoidActor.GetProperty().SetDiffuse(0.7) # sigmoidActor.GetProperty().SetSpecular(0.2) # sigmoidActor.GetProperty().SetOpacity(1.0) sphere_view = vtk.vtkSphereSource() # sphere_view.SetOrigin([-48.96,-48.96,-48.42]) # sphere_view.SetSpacing(0.18,0.18,0.18) # 210.0, 271.5, 314.5 sphere_view.SetCenter(int(814 * 0.12), int(271 * 0.12), int(710 * 0.12)) # sphere_view.SetCenter(int(250*0.18),int(150*0.18),int(600*0.18)) sphere_view.SetRadius(1.0) # sphere_view.SetColor(0.0,1.0,1.0) # mapper mapper = vtk.vtkPolyDataMapper() if vtk.VTK_MAJOR_VERSION <= 5: mapper.SetInput(sphere_view.GetOutput()) else: mapper.SetInputConnection(sphere_view.GetOutputPort()) # actor sphere_actor = vtk.vtkActor() sphere_actor.SetMapper(mapper) sphere_actor.GetProperty().SetColor(1.0, 0.0, 1.0) ren.AddActor(boneActor) ren.AddActor(skinActor) ren.AddActor(sphere_actor) # ren.AddActor(sigmoidActor) ren.AddActor(actor) iren.Initialize() renWin.Render() iren.Start()
def main(): colors = vtk.vtkNamedColors() fileName = get_program_parameters() # Create the RenderWindow, Renderer and Interactor. # ren1 = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren1) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) # Read cyberware file. # cyber = vtk.vtkPolyDataReader() cyber.SetFileName(fileName) normals = vtk.vtkPolyDataNormals() normals.SetInputConnection(cyber.GetOutputPort()) mask = vtk.vtkMaskPoints() mask.SetInputConnection(normals.GetOutputPort()) mask.SetOnRatio(8) # mask.RandomModeOn() splatter = vtk.vtkGaussianSplatter() splatter.SetInputConnection(mask.GetOutputPort()) splatter.SetSampleDimensions(100, 100, 100) splatter.SetEccentricity(2.5) splatter.NormalWarpingOn() splatter.SetScaleFactor(1.0) splatter.SetRadius(0.025) contour = vtk.vtkContourFilter() contour.SetInputConnection(splatter.GetOutputPort()) contour.SetValue(0, 0.25) splatMapper = vtk.vtkPolyDataMapper() splatMapper.SetInputConnection(contour.GetOutputPort()) splatMapper.ScalarVisibilityOff() splatActor = vtk.vtkActor() splatActor.SetMapper(splatMapper) splatActor.GetProperty().SetColor(colors.GetColor3d("Flesh")) cyberMapper = vtk.vtkPolyDataMapper() cyberMapper.SetInputConnection(cyber.GetOutputPort()) cyberMapper.ScalarVisibilityOff() cyberActor = vtk.vtkActor() cyberActor.SetMapper(cyberMapper) cyberActor.GetProperty().SetRepresentationToWireframe() cyberActor.GetProperty().SetColor(colors.GetColor3d("Turquoise")) # Add the actors to the renderer, set the background and size. # ren1.AddActor(cyberActor) ren1.AddActor(splatActor) ren1.SetBackground(colors.GetColor3d("Wheat")) renWin.SetSize(640, 480) camera = vtk.vtkCamera() camera.SetClippingRange(0.0332682, 1.66341) camera.SetFocalPoint(0.0511519, -0.127555, -0.0554379) camera.SetPosition(0.516567, -0.124763, -0.349538) camera.SetViewAngle(18.1279) camera.SetViewUp(-0.013125, 0.99985, -0.0112779) ren1.SetActiveCamera(camera) # Render the image. # renWin.Render() iren.Start()
def main(): colors = vtk.vtkNamedColors() aren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(aren) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) # Create single splat point pts = vtk.vtkPoints() verts = vtk.vtkCellArray() norms = vtk.vtkDoubleArray() scalars = vtk.vtkDoubleArray() x = [0.0] * 3 pts.InsertNextPoint(x) norms.SetNumberOfTuples(1) norms.SetNumberOfComponents(3) n = [0] * 3 n[0] = 0.707 n[1] = 0.707 n[2] = 0.0 norms.InsertTuple(0, n) scalars.SetNumberOfTuples(1) scalars.SetNumberOfComponents(1) scalars.InsertTuple1(0, 1.0) verts.InsertNextCell(1) verts.InsertCellPoint(0) pData = vtk.vtkPolyData() pData.SetPoints(pts) pData.SetVerts(verts) pData.GetPointData().SetNormals(norms) pData.GetPointData().SetScalars(scalars) # Splat point and generate isosurface. splat = vtk.vtkGaussianSplatter() splat.SetInputData(pData) splat.SetModelBounds(-1.0, 1.0, -1.0, 1.0, -1.0, 1.0) splat.SetSampleDimensions(75, 75, 75) splat.SetRadius(0.5) splat.SetEccentricity(5.0) splat.SetExponentFactor(-3.25) contour = vtk.vtkContourFilter() contour.SetInputConnection(splat.GetOutputPort()) contour.SetValue(0, 0.9) splatMapper = vtk.vtkPolyDataMapper() splatMapper.SetInputConnection(contour.GetOutputPort()) splatActor = vtk.vtkActor() splatActor.SetMapper(splatMapper) # Create outline. outline = vtk.vtkOutlineFilter() outline.SetInputConnection(splat.GetOutputPort()) outlineMapper = vtk.vtkPolyDataMapper() outlineMapper.SetInputConnection(outline.GetOutputPort()) outlineActor = vtk.vtkActor() outlineActor.SetMapper(outlineMapper) outlineActor.GetProperty().SetColor(colors.GetColor3d("Brown")) # Create cone to indicate direction. cone = vtk.vtkConeSource() cone.SetResolution(24) coneMapper = vtk.vtkPolyDataMapper() coneMapper.SetInputConnection(cone.GetOutputPort()) coneActor = vtk.vtkActor() coneActor.SetMapper(coneMapper) coneActor.SetScale(0.75, 0.75, 0.75) coneActor.RotateZ(45.0) coneActor.AddPosition(0.50, 0.50, 0.0) coneActor.GetProperty().SetColor(colors.GetColor3d("DeepPink")) # # Rendering stuff. # aren.SetBackground(colors.GetColor3d("Beige")) aren.AddActor(splatActor) aren.AddActor(outlineActor) aren.AddActor(coneActor) renWin.SetSize(640, 480) renWin.Render() # Interact with the data. iren.Start()
def testFinancialField(self): size = 3187 #maximum number possible #set size 100 #maximum number possible xAxis = "INTEREST_RATE" yAxis = "MONTHLY_PAYMENT" zAxis = "MONTHLY_INCOME" scalar = "TIME_LATE" # extract data from field as a polydata (just points), then extract scalars fdr = vtk.vtkDataObjectReader() fdr.SetFileName(VTK_DATA_ROOT + "/Data/financial.vtk") do2ds = vtk.vtkDataObjectToDataSetFilter() do2ds.SetInputConnection(fdr.GetOutputPort()) do2ds.SetDataSetTypeToPolyData() #format: component#, arrayname, arraycomp, minArrayId, maxArrayId, normalize do2ds.DefaultNormalizeOn() do2ds.SetPointComponent(0, xAxis, 0) do2ds.SetPointComponent(1, yAxis, 0, 0, size, 1) do2ds.SetPointComponent(2, zAxis, 0) do2ds.Update() fd2ad = vtk.vtkFieldDataToAttributeDataFilter() fd2ad.SetInputConnection(do2ds.GetOutputPort()) fd2ad.SetInputFieldToDataObjectField() fd2ad.SetOutputAttributeDataToPointData() fd2ad.DefaultNormalizeOn() fd2ad.SetScalarComponent(0, scalar, 0) # construct pipeline for original population popSplatter = vtk.vtkGaussianSplatter() popSplatter.SetInputConnection(fd2ad.GetOutputPort()) popSplatter.SetSampleDimensions(50, 50, 50) popSplatter.SetRadius(0.05) popSplatter.ScalarWarpingOff() popSurface = vtk.vtkMarchingContourFilter() popSurface.SetInputConnection(popSplatter.GetOutputPort()) popSurface.SetValue(0, 0.01) popMapper = vtk.vtkPolyDataMapper() popMapper.SetInputConnection(popSurface.GetOutputPort()) popMapper.ScalarVisibilityOff() popActor = vtk.vtkActor() popActor.SetMapper(popMapper) popActor.GetProperty().SetOpacity(0.3) popActor.GetProperty().SetColor(.9, .9, .9) # construct pipeline for delinquent population lateSplatter = vtk.vtkGaussianSplatter() lateSplatter.SetInputConnection(fd2ad.GetOutputPort()) lateSplatter.SetSampleDimensions(50, 50, 50) lateSplatter.SetRadius(0.05) lateSplatter.SetScaleFactor(0.05) lateSurface = vtk.vtkMarchingContourFilter() lateSurface.SetInputConnection(lateSplatter.GetOutputPort()) lateSurface.SetValue(0, 0.01) lateMapper = vtk.vtkPolyDataMapper() lateMapper.SetInputConnection(lateSurface.GetOutputPort()) lateMapper.ScalarVisibilityOff() lateActor = vtk.vtkActor() lateActor.SetMapper(lateMapper) lateActor.GetProperty().SetColor(1.0, 0.0, 0.0) # create axes popSplatter.Update() bounds = popSplatter.GetOutput().GetBounds() axes = vtk.vtkAxes() axes.SetOrigin(bounds[0], bounds[2], bounds[4]) axes.SetScaleFactor(popSplatter.GetOutput().GetLength() / 5.0) axesTubes = vtk.vtkTubeFilter() axesTubes.SetInputConnection(axes.GetOutputPort()) axesTubes.SetRadius(axes.GetScaleFactor() / 25.0) axesTubes.SetNumberOfSides(6) axesMapper = vtk.vtkPolyDataMapper() axesMapper.SetInputConnection(axesTubes.GetOutputPort()) axesActor = vtk.vtkActor() axesActor.SetMapper(axesMapper) # label the axes XText = vtk.vtkVectorText() XText.SetText(xAxis) XTextMapper = vtk.vtkPolyDataMapper() XTextMapper.SetInputConnection(XText.GetOutputPort()) XActor = vtk.vtkFollower() XActor.SetMapper(XTextMapper) XActor.SetScale(0.02, .02, .02) XActor.SetPosition(0.35, -0.05, -0.05) XActor.GetProperty().SetColor(0, 0, 0) YText = vtk.vtkVectorText() YText.SetText(yAxis) YTextMapper = vtk.vtkPolyDataMapper() YTextMapper.SetInputConnection(YText.GetOutputPort()) YActor = vtk.vtkFollower() YActor.SetMapper(YTextMapper) YActor.SetScale(0.02, .02, .02) YActor.SetPosition(-0.05, 0.35, -0.05) YActor.GetProperty().SetColor(0, 0, 0) ZText = vtk.vtkVectorText() ZText.SetText(zAxis) ZTextMapper = vtk.vtkPolyDataMapper() ZTextMapper.SetInputConnection(ZText.GetOutputPort()) ZActor = vtk.vtkFollower() ZActor.SetMapper(ZTextMapper) ZActor.SetScale(0.02, .02, .02) ZActor.SetPosition(-0.05, -0.05, 0.35) ZActor.GetProperty().SetColor(0, 0, 0) # Graphics stuff # ren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) renWin.SetWindowName("vtk - Field.Data") # Add the actors to the renderer, set the background and size # ren.AddActor(axesActor) ren.AddActor(lateActor) ren.AddActor(XActor) ren.AddActor(YActor) ren.AddActor(ZActor) ren.AddActor(popActor) #it's last because its translucent) ren.SetBackground(1, 1, 1) renWin.SetSize(400, 400) camera = vtk.vtkCamera() camera.SetClippingRange(.274, 13.72) camera.SetFocalPoint(0.433816, 0.333131, 0.449) camera.SetPosition(-1.96987, 1.15145, 1.49053) camera.SetViewUp(0.378927, 0.911821, 0.158107) ren.SetActiveCamera(camera) XActor.SetCamera(camera) YActor.SetCamera(camera) ZActor.SetCamera(camera) # render and interact with data iRen = vtk.vtkRenderWindowInteractor() iRen.SetRenderWindow(renWin); renWin.Render() img_file = "financialField.png" vtk.test.Testing.compareImage(iRen.GetRenderWindow(), vtk.test.Testing.getAbsImagePath(img_file), threshold=25) vtk.test.Testing.interact()
def testFinancialField(self): """ Demonstrate the use and manipulation of fields and use of vtkProgrammableDataObjectSource. This creates fields the hard way (as compared to reading a vtk field file), but shows you how to interface to your own raw data. The image should be the same as financialField.tcl """ xAxis = "INTEREST_RATE" yAxis = "MONTHLY_PAYMENT" zAxis = "MONTHLY_INCOME" scalar = "TIME_LATE" # Parse an ascii file and manually create a field. Then construct a # dataset from the field. dos = vtk.vtkProgrammableDataObjectSource() def parseFile(): f = open(VTK_DATA_ROOT + "/Data/financial.txt", "r") line = f.readline().split() # From the size calculate the number of lines. numPts = int(line[1]) numLines = (numPts - 1) / 8 + 1 # create the data object field = vtk.vtkFieldData() field.AllocateArrays(4) # read TIME_LATE - dependent variable while True: line = f.readline().split() if len(line) > 0: break; timeLate = vtk.vtkFloatArray() timeLate.SetName(line[0]) for i in range(0, numLines): line = f.readline().split() for j in line: timeLate.InsertNextValue(float(j)) field.AddArray(timeLate) # MONTHLY_PAYMENT - independent variable while True: line = f.readline().split() if len(line) > 0: break; monthlyPayment = vtk.vtkFloatArray() monthlyPayment.SetName(line[0]) for i in range(0, numLines): line = f.readline().split() for j in line: monthlyPayment.InsertNextValue(float(j)) field.AddArray(monthlyPayment) # UNPAID_PRINCIPLE - skip while True: line = f.readline().split() if len(line) > 0: break; for i in range(0, numLines): line = f.readline() # LOAN_AMOUNT - skip while True: line = f.readline().split() if len(line) > 0: break; for i in range(0, numLines): line = f.readline() # INTEREST_RATE - independent variable while True: line = f.readline().split() if len(line) > 0: break; interestRate = vtk.vtkFloatArray() interestRate.SetName(line[0]) for i in range(0, numLines): line = f.readline().split() for j in line: interestRate.InsertNextValue(float(j)) field.AddArray(interestRate) # MONTHLY_INCOME - independent variable while True: line = f.readline().split() if len(line) > 0: break; monthlyIncome = vtk.vtkFloatArray() monthlyIncome.SetName(line[0]) for i in range(0, numLines): line = f.readline().split() for j in line: monthlyIncome.InsertNextValue(float(j)) field.AddArray(monthlyIncome) dos.GetOutput().SetFieldData(field) dos.SetExecuteMethod(parseFile) # Create the dataset do2ds = vtk.vtkDataObjectToDataSetFilter() do2ds.SetInputConnection(dos.GetOutputPort()) do2ds.SetDataSetTypeToPolyData() #format: component#, arrayname, arraycomp, minArrayId, maxArrayId, normalize do2ds.DefaultNormalizeOn() do2ds.SetPointComponent(0, xAxis, 0) do2ds.SetPointComponent(1, yAxis, 0) do2ds.SetPointComponent(2, zAxis, 0) do2ds.Update() rf = vtk.vtkRearrangeFields() rf.SetInputConnection(do2ds.GetOutputPort()) rf.AddOperation("MOVE", scalar, "DATA_OBJECT", "POINT_DATA") rf.RemoveOperation("MOVE", scalar, "DATA_OBJECT", "POINT_DATA") rf.AddOperation("MOVE", scalar, "DATA_OBJECT", "POINT_DATA") rf.RemoveAllOperations() rf.AddOperation("MOVE", scalar, "DATA_OBJECT", "POINT_DATA") rf.Update() max = rf.GetOutput().GetPointData().GetArray(scalar).GetRange(0)[1] calc = vtk.vtkArrayCalculator() calc.SetInputConnection(rf.GetOutputPort()) calc.SetAttributeModeToUsePointData() calc.SetFunction("s / %f" % max) calc.AddScalarVariable("s", scalar, 0) calc.SetResultArrayName("resArray") aa = vtk.vtkAssignAttribute() aa.SetInputConnection(calc.GetOutputPort()) aa.Assign("resArray", "SCALARS", "POINT_DATA") aa.Update() rf2 = vtk.vtkRearrangeFields() rf2.SetInputConnection(aa.GetOutputPort()) rf2.AddOperation("COPY", "SCALARS", "POINT_DATA", "DATA_OBJECT") # construct pipeline for original population popSplatter = vtk.vtkGaussianSplatter() popSplatter.SetInputConnection(rf2.GetOutputPort()) popSplatter.SetSampleDimensions(50, 50, 50) popSplatter.SetRadius(0.05) popSplatter.ScalarWarpingOff() popSurface = vtk.vtkContourFilter() popSurface.SetInputConnection(popSplatter.GetOutputPort()) popSurface.SetValue(0, 0.01) popMapper = vtk.vtkPolyDataMapper() popMapper.SetInputConnection(popSurface.GetOutputPort()) popMapper.ScalarVisibilityOff() popMapper.ImmediateModeRenderingOn() popActor = vtk.vtkActor() popActor.SetMapper(popMapper) popActor.GetProperty().SetOpacity(0.3) popActor.GetProperty().SetColor(.9, .9, .9) # construct pipeline for delinquent population lateSplatter = vtk.vtkGaussianSplatter() lateSplatter.SetInputConnection(aa.GetOutputPort()) lateSplatter.SetSampleDimensions(50, 50, 50) lateSplatter.SetRadius(0.05) lateSplatter.SetScaleFactor(0.05) lateSurface = vtk.vtkContourFilter() lateSurface.SetInputConnection(lateSplatter.GetOutputPort()) lateSurface.SetValue(0, 0.01) lateMapper = vtk.vtkPolyDataMapper() lateMapper.SetInputConnection(lateSurface.GetOutputPort()) lateMapper.ScalarVisibilityOff() lateActor = vtk.vtkActor() lateActor.SetMapper(lateMapper) lateActor.GetProperty().SetColor(1.0, 0.0, 0.0) # create axes popSplatter.Update() bounds = popSplatter.GetOutput().GetBounds() axes = vtk.vtkAxes() axes.SetOrigin(bounds[0], bounds[2], bounds[4]) axes.SetScaleFactor(popSplatter.GetOutput().GetLength() / 5.0) axesTubes = vtk.vtkTubeFilter() axesTubes.SetInputConnection(axes.GetOutputPort()) axesTubes.SetRadius(axes.GetScaleFactor() / 25.0) axesTubes.SetNumberOfSides(6) axesMapper = vtk.vtkPolyDataMapper() axesMapper.SetInputConnection(axesTubes.GetOutputPort()) axesActor = vtk.vtkActor() axesActor.SetMapper(axesMapper) # label the axes XText = vtk.vtkVectorText() XText.SetText(xAxis) XTextMapper = vtk.vtkPolyDataMapper() XTextMapper.SetInputConnection(XText.GetOutputPort()) XActor = vtk.vtkFollower() XActor.SetMapper(XTextMapper) XActor.SetScale(0.02, .02, .02) XActor.SetPosition(0.35, -0.05, -0.05) XActor.GetProperty().SetColor(0, 0, 0) YText = vtk.vtkVectorText() YText.SetText(yAxis) YTextMapper = vtk.vtkPolyDataMapper() YTextMapper.SetInputConnection(YText.GetOutputPort()) YActor = vtk.vtkFollower() YActor.SetMapper(YTextMapper) YActor.SetScale(0.02, .02, .02) YActor.SetPosition(-0.05, 0.35, -0.05) YActor.GetProperty().SetColor(0, 0, 0) ZText = vtk.vtkVectorText() ZText.SetText(zAxis) ZTextMapper = vtk.vtkPolyDataMapper() ZTextMapper.SetInputConnection(ZText.GetOutputPort()) ZActor = vtk.vtkFollower() ZActor.SetMapper(ZTextMapper) ZActor.SetScale(0.02, .02, .02) ZActor.SetPosition(-0.05, -0.05, 0.35) ZActor.GetProperty().SetColor(0, 0, 0) # Graphics stuff # ren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) renWin.SetWindowName("vtk(-, Field.Data") renWin.SetSize(300, 300) # Add the actors to the renderer, set the background and size # ren.AddActor(axesActor) ren.AddActor(lateActor) ren.AddActor(XActor) ren.AddActor(YActor) ren.AddActor(ZActor) ren.AddActor(popActor) #it's last because its translucent) ren.SetBackground(1, 1, 1) camera = vtk.vtkCamera() camera.SetClippingRange(.274, 13.72) camera.SetFocalPoint(0.433816, 0.333131, 0.449) camera.SetPosition(-1.96987, 1.15145, 1.49053) camera.SetViewUp(0.378927, 0.911821, 0.158107) ren.SetActiveCamera(camera) XActor.SetCamera(camera) YActor.SetCamera(camera) ZActor.SetCamera(camera) # render and interact with data iRen = vtk.vtkRenderWindowInteractor() iRen.SetRenderWindow(renWin); renWin.Render() img_file = "financialField3.png" vtk.test.Testing.compareImage(iRen.GetRenderWindow(), vtk.test.Testing.getAbsImagePath(img_file), threshold=25) vtk.test.Testing.interact()
def Add_ClusterActors(self,ASDdata,iren,renWin,ren): import vtk ######################################################################## # Data structures for the impurity cluster ######################################################################## # Passing the data from the cluster to the PolyData src_clus=vtk.vtkPolyData() src_clus.SetPoints(ASDdata.coord_c) src_clus.GetPointData().SetScalars(ASDdata.colors_clus) # Passing the data from the selected impurities src_imp=vtk.vtkPolyData() src_imp.SetPoints(ASDdata.points_clus_imp) src_imp.GetPointData().SetScalars(ASDdata.colors_imp) src_imp.Modified() # Setting up the gaussian splatter for the clusters atomSource = vtk.vtkGaussianSplatter() atomSource.SetInputData(src_clus) atomSource.SetRadius(0.100) atomSource.ScalarWarpingOff() atomSource.SetExponentFactor(-20) atomSource.Update() bound=atomSource.GetModelBounds() atomSource.SetModelBounds(bound[0],bound[1],bound[2],bound[3],bound[4]*0.25,bound[5]*0.25) atomSource.Update() # Setting up a contour filter atomSurface = vtk.vtkContourFilter() atomSurface.SetInputConnection(atomSource.GetOutputPort()) atomSurface.SetValue(0, 0.01) # Setting up the mapper atomMapper = vtk.vtkPolyDataMapper() atomMapper.SetInputConnection(atomSurface.GetOutputPort()) atomMapper.ScalarVisibilityOff() # Creating the actor for the smooth surfaces ASDGenActors.atom = vtk.vtkActor() ASDGenActors.atom.SetMapper(atomMapper) ASDGenActors.atom.GetProperty().SetColor(0.0,0.0,0.0) ASDGenActors.atom.GetProperty().EdgeVisibilityOff() ASDGenActors.atom.GetProperty().SetSpecularPower(30) ASDGenActors.atom.GetProperty().SetAmbient(0.2) ASDGenActors.atom.GetProperty().SetDiffuse(0.8) ASDGenActors.atom.GetProperty().SetOpacity(0.25) # Set up imp sources atomSource_imp = vtk.vtkSphereSource() atomSource_imp.SetRadius(2.5) atomSource_imp.SetThetaResolution(20) atomSource_imp.SetPhiResolution(20) # Mapping the spheres to the actual points on the selected impurities atomMapper_imp = vtk.vtkGlyph3DMapper() atomMapper_imp.SetInputData(src_imp) atomMapper_imp.SetSourceConnection(atomSource_imp.GetOutputPort()) atomMapper_imp.SetScaleFactor(0.2) atomMapper_imp.SetScaleModeToNoDataScaling() atomMapper_imp.Update() # Creating the selected impurity actors ASDGenActors.atom_imp = vtk.vtkLODActor() ASDGenActors.atom_imp.SetMapper(atomMapper_imp) ASDGenActors.atom_imp.GetProperty().SetSpecular(0.3) ASDGenActors.atom_imp.GetProperty().SetSpecularPower(30) ASDGenActors.atom_imp.GetProperty().SetAmbient(0.2) ASDGenActors.atom_imp.GetProperty().SetDiffuse(0.8) # If there is information about the cluster add the needed actors ren.AddActor(ASDGenActors.atom) ren.AddActor(ASDGenActors.atom_imp) ######################################################################## # Start the renderer ######################################################################## iren.Start() renWin.Render() return