def make_colors(n): """ Generate some random colors :param n: The number of colors. :return: The lookup table. """ lut = vtk.vtkLookupTable() lut.SetNumberOfColors(n) lut.SetTableRange(0, n - 1) lut.SetScaleToLinear() lut.Build() lut.SetTableValue(0, 0, 0, 0, 1) random_sequence = vtk.vtkMinimalStandardRandomSequence() random_sequence.SetSeed(5071) for i in range(1, n): r = random_sequence.GetRangeValue(0.4, 1) random_sequence.Next() g = random_sequence.GetRangeValue(0.4, 1) random_sequence.Next() b = random_sequence.GetRangeValue(0.4, 1) random_sequence.Next() lut.SetTableValue(i, r, g, b, 1.0) return lut
def main(): colors = vtk.vtkNamedColors() # Create points on an XY grid with random Z coordinate points = vtk.vtkPoints() gridSize = 10 seed = 0 randomSequence = vtk.vtkMinimalStandardRandomSequence() randomSequence.Initialize(seed) for x in range(0, gridSize): for y in range(0, gridSize): d = randomSequence.GetValue() randomSequence.Next() points.InsertNextPoint(x, y, d * 3) # Add the grid points to a polydata object polydata = vtk.vtkPolyData() polydata.SetPoints(points) glyphFilter = vtk.vtkVertexGlyphFilter() glyphFilter.SetInputData(polydata) glyphFilter.Update() # Create a mapper and actor pointsMapper = vtk.vtkPolyDataMapper() pointsMapper.SetInputConnection(glyphFilter.GetOutputPort()) pointsActor = vtk.vtkActor() pointsActor.SetMapper(pointsMapper) pointsActor.GetProperty().SetPointSize(3) pointsActor.GetProperty().SetColor(colors.GetColor3d("Red")) # Triangulate the grid points delaunay = vtk.vtkDelaunay2D() delaunay.SetInputData(polydata) delaunay.Update() # Create a mapper and actor triangulatedMapper = vtk.vtkPolyDataMapper() triangulatedMapper.SetInputConnection(delaunay.GetOutputPort()) triangulatedActor = vtk.vtkActor() triangulatedActor.SetMapper(triangulatedMapper) # Create a renderer, render window, and interactor renderer = vtk.vtkRenderer() renderWindow = vtk.vtkRenderWindow() renderWindow.AddRenderer(renderer) renderWindowInteractor = vtk.vtkRenderWindowInteractor() renderWindowInteractor.SetRenderWindow(renderWindow) # Add the actor to the scene renderer.AddActor(pointsActor) renderer.AddActor(triangulatedActor) renderer.SetBackground(colors.GetColor3d("Green")) # Background color green # Render and interact renderWindow.SetWindowName('TriangulateTerrainMap') renderWindow.Render() renderWindowInteractor.Start()
def create_arrow(pd_length, start_point, end_point): # Create an arrow. arrow_source = vtk.vtkArrowSource() arrow_source.SetShaftRadius(pd_length * 0.01) arrow_source.SetShaftResolution(20) arrow_source.SetTipLength(pd_length * 0.1) arrow_source.SetTipRadius(pd_length * 0.05) arrow_source.SetTipResolution(20) # Compute a basis normalized_x = [0.0, 0.0, 0.0] normalized_y = [0.0, 0.0, 0.0] normalized_z = [0.0, 0.0, 0.0] # The X axis is a vector from start to end vtk.vtkMath.Subtract(end_point, start_point, normalized_x) length = vtk.vtkMath.Norm(normalized_x) vtk.vtkMath.Normalize(normalized_x) # The Z axis is an arbitrary vector cross X rng = vtk.vtkMinimalStandardRandomSequence() rng.SetSeed(8775070) # For testing. arbitrary = [0.0, 0.0, 0.0] for i in range(0, 3): rng.Next() arbitrary[i] = rng.GetRangeValue(-10, 10) vtk.vtkMath.Cross(normalized_x, arbitrary, normalized_z) vtk.vtkMath.Normalize(normalized_z) # The Y axis is Z cross X vtk.vtkMath.Cross(normalized_z, normalized_x, normalized_y) matrix = vtk.vtkMatrix4x4() # Create the direction cosine matrix matrix.Identity() for i in range(0, 3): matrix.SetElement(i, 0, normalized_x[i]) matrix.SetElement(i, 1, normalized_y[i]) matrix.SetElement(i, 2, normalized_z[i]) # Apply the transforms transform = vtk.vtkTransform() transform.Translate(start_point) transform.Concatenate(matrix) transform.Scale(length, length, length) # Transform the poly_data transform_pd = vtk.vtkTransformPolyDataFilter() transform_pd.SetTransform(transform) transform_pd.SetInputConnection(arrow_source.GetOutputPort()) transform_pd.Update() poly_data = transform_pd.GetOutput() return poly_data
def CreateArrow(pdLength, startPoint, endPoint): polyData = vtk.vtkPolyData() # Create an arrow. arrowSource = vtk.vtkArrowSource() arrowSource.SetShaftRadius(pdLength * .01) arrowSource.SetShaftResolution(20) arrowSource.SetTipLength(pdLength * .1) arrowSource.SetTipRadius(pdLength * .05) arrowSource.SetTipResolution(20) # Compute a basis normalizedX = vtk.vtkVector3d() normalizedY = vtk.vtkVector3d() normalizedZ = vtk.vtkVector3d() # The X axis is a vector from start to end vtk.vtkMath.Subtract(endPoint, startPoint, normalizedX) length = vtk.vtkMath.Norm(normalizedX) vtk.vtkMath.Normalize(normalizedX) # The Z axis is an arbitrary vector cross X rng = vtk.vtkMinimalStandardRandomSequence() rng.SetSeed(8775070) # For testing. arbitrary = vtk.vtkVector3d() for i in range(3): rng.Next() arbitrary[i] = rng.GetRangeValue(-10, 10) vtk.vtkMath.Cross(normalizedX, arbitrary, normalizedZ) vtk.vtkMath.Normalize(normalizedZ) # The Y axis is Z cross X vtk.vtkMath.Cross(normalizedZ, normalizedX, normalizedY) matrix = vtk.vtkMatrix4x4() # Create the direction cosine matrix matrix.Identity() for i in range(3): matrix.SetElement(i, 0, normalizedX[i]) matrix.SetElement(i, 1, normalizedY[i]) matrix.SetElement(i, 2, normalizedZ[i]) # Apply the transforms transform = vtk.vtkTransform() transform.Translate(startPoint) transform.Concatenate(matrix) transform.Scale(length, length, length) # Transform the polydata transformPD = vtk.vtkTransformPolyDataFilter() transformPD.SetTransform(transform) transformPD.SetInputConnection(arrowSource.GetOutputPort()) transformPD.Update() polyData = transformPD.GetOutput() return polyData
def ReadPolyData(fileName): polyData = vtk.vtkPolyData() extension = fileName.split(".")[-1].lower() if (extension == "ply"): reader = vtk.vtkPLYReader() reader.SetFileName(fileName) reader.Update() polyData = reader.GetOutput() elif (extension == "vtp"): reader = vtk.vtkXMLPolyDataReader() reader.SetFileName(fileName) reader.Update() polyData = reader.GetOutput() elif (extension == "vtk"): reader = vtk.vtkPolyDataReader() reader.SetFileName(fileName) reader.Update() polyData = reader.GetOutput() elif (extension == "obj"): reader = vtk.vtkOBJReader() reader.SetFileName(fileName) reader.Update() polyData = reader.GetOutput() elif (extension == "stl"): reader = vtk.vtkSTLReader() reader.SetFileName(fileName) reader.Update() polyData = reader.GetOutput() elif (extension == "g"): reader = vtk.vtkBYUReader() reader.SetGeometryFileName(fileName) reader.Update() polyData = reader.GetOutput() else: randomSequence = vtk.vtkMinimalStandardRandomSequence() randomSequence.SetSeed(8775070) points = vtk.vtkPointSource() points.SetNumberOfPoints(100000) points.SetRadius(10.0) # Random position x = randomSequence.GetRangeValue(-100, 100) randomSequence.Next() y = randomSequence.GetRangeValue(-100, 100) randomSequence.Next() z = randomSequence.GetRangeValue(-100, 100) randomSequence.Next() points.SetCenter(x, y, z) points.SetDistributionToShell() points.Update() polyData = points.GetOutput() return polyData
def arrow(self, start, end): base_length = self.project.preprocessor.structure_principal_diagonal/10 arrowSource = vtk.vtkArrowSource() startPoint = start endPoint = end rng = vtk.vtkMinimalStandardRandomSequence() rng.SetSeed(8775070) # For testing. normalizedX = [0] * 3 normalizedY = [0] * 3 normalizedZ = [0] * 3 vtk.vtkMath.Subtract(endPoint, startPoint, normalizedX) length = vtk.vtkMath.Norm(normalizedX) vtk.vtkMath.Normalize(normalizedX) arbitrary = [0] * 3 for i in range(0, 3): rng.Next() arbitrary[i] = rng.GetRangeValue(-10, 10) vtk.vtkMath.Cross(normalizedX, arbitrary, normalizedZ) vtk.vtkMath.Normalize(normalizedZ) vtk.vtkMath.Cross(normalizedZ, normalizedX, normalizedY) matrix = vtk.vtkMatrix4x4() matrix.Identity() for i in range(0, 3): matrix.SetElement(i, 0, normalizedX[i]) matrix.SetElement(i, 1, normalizedY[i]) matrix.SetElement(i, 2, normalizedZ[i]) transform = vtk.vtkTransform() transform.Translate(startPoint) transform.Concatenate(matrix) #transform.Scale(length, length, length) transform.Scale(self.project.get_element_size(), self.project.get_element_size(), self.project.get_element_size()) transformPD = vtk.vtkTransformPolyDataFilter() transformPD.SetTransform(transform) transformPD.SetInputConnection(arrowSource.GetOutputPort()) mapper = vtk.vtkPolyDataMapper() actor = vtk.vtkActor() mapper.SetInputConnection(arrowSource.GetOutputPort()) actor.SetUserMatrix(transform.GetMatrix()) actor.SetMapper(mapper) return actor
def make_blob(n, radius): blob_image = vtk.vtkImageData() max_r = 50 - 2.0 * radius random_sequence = vtk.vtkMinimalStandardRandomSequence() random_sequence.SetSeed(5071) for i in range(0, n): sphere = vtk.vtkSphere() sphere.SetRadius(radius) x = random_sequence.GetRangeValue(-max_r, max_r) random_sequence.Next() y = random_sequence.GetRangeValue(-max_r, max_r) random_sequence.Next() z = random_sequence.GetRangeValue(-max_r, max_r) random_sequence.Next() sphere.SetCenter(int(x), int(y), int(z)) sampler = vtk.vtkSampleFunction() sampler.SetImplicitFunction(sphere) sampler.SetOutputScalarTypeToFloat() sampler.SetSampleDimensions(100, 100, 100) sampler.SetModelBounds(-50, 50, -50, 50, -50, 50) thres = vtk.vtkImageThreshold() thres.SetInputConnection(sampler.GetOutputPort()) thres.ThresholdByLower(radius * radius) thres.ReplaceInOn() thres.ReplaceOutOn() thres.SetInValue(i + 1) thres.SetOutValue(0) thres.Update() if i == 0: blob_image.DeepCopy(thres.GetOutput()) max_value = vtk.vtkImageMathematics() max_value.SetInputData(0, blob_image) max_value.SetInputData(1, thres.GetOutput()) max_value.SetOperationToMax() max_value.Modified() max_value.Update() blob_image.DeepCopy(max_value.GetOutput()) return blob_image
def main(): # Create a random sequence generator. sequence = vtk.vtkMinimalStandardRandomSequence() # initialize the sequence sequence.SetSeed(int(time.time())) # Get 3 random numbers. x = sequence.GetValue() sequence.Next() y = sequence.GetValue() sequence.Next() z = sequence.GetValue() # You can also use seq.GetRangeValue(-1.0, 1.0) # to set a range on the random values. # Output the resulting random numbersl print("x:", x, "y:", y, "z:", z)
def MakeQuadraticHexahedron(): aHexahedron = vtk.vtkQuadraticHexahedron() points = vtk.vtkPoints() pcoords = aHexahedron.GetParametricCoords() rng = vtk.vtkMinimalStandardRandomSequence() points.SetNumberOfPoints(aHexahedron.GetNumberOfPoints()) rng.SetSeed(5070) # for testing for i in range(0, aHexahedron.GetNumberOfPoints()): perturbation = [0.0] * 3 for j in range(0, 3): rng.Next() perturbation[j] = rng.GetRangeValue(-0.1, 0.1) aHexahedron.GetPointIds().SetId(i, i) points.SetPoint(i, pcoords[3 * i] + perturbation[0], pcoords[3 * i + 1] + perturbation[1], pcoords[3 * i + 2] + perturbation[2]) # Add the points and hexahedron to an unstructured grid uGrid = vtk.vtkUnstructuredGrid() uGrid.SetPoints(points) uGrid.InsertNextCell(aHexahedron.GetCellType(), aHexahedron.GetPointIds()) return uGrid
def get_parametric_functions(): """ Create a map of the parametric functions and set some parameters. The first key groups the parametric functions and the second key is the name of the function. :return: The map of functions. """ # We could use OrderedDict if Python version >= 3.2 pfn = collections.defaultdict(collections.defaultdict) pfn[0]['Boy'] = vtk.vtkParametricBoy() pfn[0]['ConicSpiral'] = vtk.vtkParametricConicSpiral() pfn[0]['CrossCap'] = vtk.vtkParametricCrossCap() pfn[0]['Dini'] = vtk.vtkParametricDini() pfn[0]['Ellipsoid'] = vtk.vtkParametricEllipsoid() pfn[0]['Enneper'] = vtk.vtkParametricEnneper() pfn[0]['Figure8Klein'] = vtk.vtkParametricFigure8Klein() pfn[0]['Klein'] = vtk.vtkParametricKlein() pfn[0]['Mobius'] = vtk.vtkParametricMobius() pfn[0]['RandomHills'] = vtk.vtkParametricRandomHills() pfn[0]['Roman'] = vtk.vtkParametricRoman() pfn[0]['SuperEllipsoid'] = vtk.vtkParametricSuperEllipsoid() pfn[0]['SuperToroid'] = vtk.vtkParametricSuperToroid() pfn[0]['Torus'] = vtk.vtkParametricTorus() pfn[0]['Spline'] = vtk.vtkParametricSpline() # Extra parametric surfaces. pfn[1]['BohemianDome'] = vtk.vtkParametricBohemianDome() pfn[1]['Bour'] = vtk.vtkParametricBour() pfn[1]['CatalanMinimal'] = vtk.vtkParametricCatalanMinimal() pfn[1]['Henneberg'] = vtk.vtkParametricHenneberg() pfn[1]['Kuen'] = vtk.vtkParametricKuen() pfn[1]['PluckerConoid'] = vtk.vtkParametricPluckerConoid() pfn[1]['Pseudosphere'] = vtk.vtkParametricPseudosphere() # Now set some parameters. pfn[0]["Ellipsoid"].SetXRadius(0.5) pfn[0]["Ellipsoid"].SetYRadius(2.0) pfn[0]["Mobius"].SetRadius(2.0) pfn[0]["Mobius"].SetMinimumV(-0.5) pfn[0]["Mobius"].SetMaximumV(0.5) pfn[0]["RandomHills"].AllowRandomGenerationOn() pfn[0]["RandomHills"].SetRandomSeed(1) pfn[0]["RandomHills"].SetNumberOfHills(30) pfn[0]["SuperEllipsoid"].SetN1(0.5) pfn[0]["SuperEllipsoid"].SetN2(0.4) pfn[0]["SuperToroid"].SetN1(0.5) pfn[0]["SuperToroid"].SetN2(3.0) # The spline needs points inputPoints = vtk.vtkPoints() rng = vtk.vtkMinimalStandardRandomSequence() rng.SetSeed(8775070) for p in range(0, 10): xyz = [None] * 3 for idx in range(0, len(xyz)): xyz[idx] = rng.GetRangeValue(-1.0, 1.0) rng.Next() inputPoints.InsertNextPoint(xyz) pfn[0]["Spline"].SetPoints(inputPoints) # Extra parametric surfaces. pfn[1]["BohemianDome"].SetA(5.0) pfn[1]["BohemianDome"].SetB(1.0) pfn[1]["BohemianDome"].SetC(2.0) pfn[1]["Kuen"].SetDeltaV0(0.001) return pfn
def main(): nc = vtk.vtkNamedColors() # Make a 32 x 32 grid size = 32 rn = vtk.vtkMinimalStandardRandomSequence() rn.SetSeed(1) # Define z values for the topography (random height) topography = numpy.zeros([size, size]) for i in range(size): for j in range(size): topography[i][j] = rn.GetRangeValue(0, 5) rn.Next() # Define points, triangles and colors colors = vtk.vtkUnsignedCharArray() colors.SetNumberOfComponents(3) points = vtk.vtkPoints() triangles = vtk.vtkCellArray() # Build the meshgrid manually count = 0 for i in range(size - 1): for j in range(size - 1): z1 = topography[i][j] z2 = topography[i][j + 1] z3 = topography[i + 1][j] # Triangle 1 points.InsertNextPoint(i, j, z1) points.InsertNextPoint(i, (j + 1), z2) points.InsertNextPoint((i + 1), j, z3) triangle = vtk.vtkTriangle() triangle.GetPointIds().SetId(0, count) triangle.GetPointIds().SetId(1, count + 1) triangle.GetPointIds().SetId(2, count + 2) triangles.InsertNextCell(triangle) z1 = topography[i][j + 1] z2 = topography[i + 1][j + 1] z3 = topography[i + 1][j] # Triangle 2 points.InsertNextPoint(i, (j + 1), z1) points.InsertNextPoint((i + 1), (j + 1), z2) points.InsertNextPoint((i + 1), j, z3) triangle = vtk.vtkTriangle() triangle.GetPointIds().SetId(0, count + 3) triangle.GetPointIds().SetId(1, count + 4) triangle.GetPointIds().SetId(2, count + 5) count += 6 triangles.InsertNextCell(triangle) # Add some color r = [int(i / float(size) * 255), int(j / float(size) * 255), 0] colors.InsertNextTypedTuple(r) colors.InsertNextTypedTuple(r) colors.InsertNextTypedTuple(r) colors.InsertNextTypedTuple(r) colors.InsertNextTypedTuple(r) colors.InsertNextTypedTuple(r) # Create a polydata object trianglePolyData = vtk.vtkPolyData() # Add the geometry and topology to the polydata trianglePolyData.SetPoints(points) trianglePolyData.GetPointData().SetScalars(colors) trianglePolyData.SetPolys(triangles) # Clean the polydata so that the edges are shared ! cleanPolyData = vtk.vtkCleanPolyData() cleanPolyData.SetInputData(trianglePolyData) # Use a filter to smooth the data (will add triangles and smooth) # Use two different filters to show the difference smooth_loop = vtk.vtkLoopSubdivisionFilter() smooth_loop.SetNumberOfSubdivisions(3) smooth_loop.SetInputConnection(cleanPolyData.GetOutputPort()) smooth_butterfly = vtk.vtkButterflySubdivisionFilter() smooth_butterfly.SetNumberOfSubdivisions(3) smooth_butterfly.SetInputConnection(cleanPolyData.GetOutputPort()) # Create a mapper and actor for initial dataset mapper = vtk.vtkPolyDataMapper() mapper.SetInputData(trianglePolyData) actor = vtk.vtkActor() actor.SetMapper(mapper) # Create a mapper and actor for smoothed dataset (vtkLoopSubdivisionFilter) mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(smooth_loop.GetOutputPort()) actor_loop = vtk.vtkActor() actor_loop.SetMapper(mapper) actor_loop.SetPosition(32, 0, 0) # Create a mapper and actor for smoothed dataset (vtkButterflySubdivisionFilter) mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(smooth_butterfly.GetOutputPort()) actor_butterfly = vtk.vtkActor() actor_butterfly.SetMapper(mapper) actor_butterfly.SetPosition(64, 0, 0) # Visualise renderer = vtk.vtkRenderer() renderWindow = vtk.vtkRenderWindow() renderWindow.AddRenderer(renderer) renderWindowInteractor = vtk.vtkRenderWindowInteractor() renderWindowInteractor.SetRenderWindow(renderWindow) # Add actors and render renderer.AddActor(actor) renderer.AddActor(actor_loop) renderer.AddActor(actor_butterfly) renderer.SetBackground(nc.GetColor3d('AliceBlue')) renderWindow.SetSize(900, 300) renderWindow.Render() renderer.GetActiveCamera().Elevation(-45) renderer.GetActiveCamera().Zoom(3) renderWindow.Render() renderWindowInteractor.Start()
def main(): colors = vtk.vtkNamedColors() colors.SetColor("BkgColor", [26, 51, 102, 255]) parametricObjects = list() parametricObjects.append(vtk.vtkParametricBoy()) parametricObjects.append(vtk.vtkParametricConicSpiral()) parametricObjects.append(vtk.vtkParametricCrossCap()) parametricObjects.append(vtk.vtkParametricDini()) parametricObjects.append(vtk.vtkParametricEllipsoid()) parametricObjects[-1].SetXRadius(0.5) parametricObjects[-1].SetYRadius(2.0) parametricObjects.append(vtk.vtkParametricEnneper()) parametricObjects.append(vtk.vtkParametricFigure8Klein()) parametricObjects.append(vtk.vtkParametricKlein()) parametricObjects.append(vtk.vtkParametricMobius()) parametricObjects[-1].SetRadius(2) parametricObjects[-1].SetMinimumV(-0.5) parametricObjects[-1].SetMaximumV(0.5) parametricObjects.append(vtk.vtkParametricRandomHills()) parametricObjects[-1].AllowRandomGenerationOff() parametricObjects.append(vtk.vtkParametricRoman()) parametricObjects.append(vtk.vtkParametricSuperEllipsoid()) parametricObjects[-1].SetN1(0.5) parametricObjects[-1].SetN2(0.1) parametricObjects.append(vtk.vtkParametricSuperToroid()) parametricObjects[-1].SetN1(0.2) parametricObjects[-1].SetN2(3.0) parametricObjects.append(vtk.vtkParametricTorus()) parametricObjects.append(vtk.vtkParametricSpline()) # Add some points to the parametric spline. inputPoints = vtk.vtkPoints() rng = vtk.vtkMinimalStandardRandomSequence() rng.SetSeed(8775070) for i in range(0, 10): rng.Next() x = rng.GetRangeValue(0.0, 1.0) rng.Next() y = rng.GetRangeValue(0.0, 1.0) rng.Next() z = rng.GetRangeValue(0.0, 1.0) inputPoints.InsertNextPoint(x, y, z) parametricObjects[-1].SetPoints(inputPoints) parametricFunctionSources = list() renderers = list() mappers = list() actors = list() textmappers = list() textactors = list() # Create one text property for all textProperty = vtk.vtkTextProperty() textProperty.SetFontSize(12) textProperty.SetJustificationToCentered() backProperty = vtk.vtkProperty() backProperty.SetColor(colors.GetColor3d("Tomato")) # Create a parametric function source, renderer, mapper, and actor # for each object for i in range(0, len(parametricObjects)): parametricFunctionSources.append(vtk.vtkParametricFunctionSource()) parametricFunctionSources[i].SetParametricFunction(parametricObjects[i]) parametricFunctionSources[i].SetUResolution(51) parametricFunctionSources[i].SetVResolution(51) parametricFunctionSources[i].SetWResolution(51) parametricFunctionSources[i].Update() mappers.append(vtk.vtkPolyDataMapper()) mappers[i].SetInputConnection(parametricFunctionSources[i].GetOutputPort()) actors.append(vtk.vtkActor()) actors[i].SetMapper(mappers[i]) actors[i].GetProperty().SetColor(colors.GetColor3d("Banana")) actors[i].GetProperty().SetSpecular(.5) actors[i].GetProperty().SetSpecularPower(20) actors[i].SetBackfaceProperty(backProperty) textmappers.append(vtk.vtkTextMapper()) textmappers[i].SetInput(parametricObjects[i].GetClassName()) textmappers[i].SetTextProperty(textProperty) textactors.append(vtk.vtkActor2D()) textactors[i].SetMapper(textmappers[i]) textactors[i].SetPosition(100, 16) renderers.append(vtk.vtkRenderer()) renderers[i].AddActor(actors[i]) renderers[i].AddActor(textactors[i]) renderers[i].SetBackground(colors.GetColor3d("BkgColor")) # Setup the viewports xGridDimensions = 4 yGridDimensions = 4 rendererSize = 200 renderWindow = vtk.vtkRenderWindow() renderWindow.SetWindowName("Parametric Objects Demonstration") renderWindow.SetSize(rendererSize * xGridDimensions, rendererSize * yGridDimensions) for row in range(0, yGridDimensions): for col in range(0, xGridDimensions): index = row * xGridDimensions + col # (xmin, ymin, xmax, ymax) viewport = [float(col) / xGridDimensions, float(yGridDimensions - (row + 1)) / yGridDimensions, float(col + 1) / xGridDimensions, float(yGridDimensions - row) / yGridDimensions] if index > (len(actors) - 1): # Add a renderer even if there is no actor. # This makes the render window background all the same color. ren = vtk.vtkRenderer() ren.SetBackground(colors.GetColor3d("BkgColor")) ren.SetViewport(viewport) renderWindow.AddRenderer(ren) continue renderers[index].SetViewport(viewport) renderers[index].ResetCamera() renderers[index].GetActiveCamera().Azimuth(30) renderers[index].GetActiveCamera().Elevation(-30) renderers[index].GetActiveCamera().Zoom(0.9) renderers[index].ResetCameraClippingRange() renderWindow.AddRenderer(renderers[index]) interactor = vtk.vtkRenderWindowInteractor() interactor.SetRenderWindow(renderWindow) renderWindow.Render() interactor.Start()
def main(argv): if (len(argv) < 2): print("Usage: GLTFExporter file.gltf") colors = vtk.vtkNamedColors() # Set the background color. backgroundColor = colors.GetColor3d("SlateGray") # Create an arrow. arrowSource = vtk.vtkArrowSource() # Generate a random start and end point rng = vtk.vtkMinimalStandardRandomSequence() rng.SetSeed(8775070) # For testing. startPoint = [0,0,0] endPoint = [0,0,0] for i in range(3): rng.Next() startPoint[i] = rng.GetRangeValue(-10, 10) rng.Next() endPoint[i] = rng.GetRangeValue(-10, 10) # Compute a basis normalizedX = [0,0,0] normalizedY = [0,0,0] normalizedZ = [0,0,0] # The X axis is a vector from start to end vtk.vtkMath.Subtract(endPoint, startPoint, normalizedX) length = vtk.vtkMath.Norm(normalizedX) vtk.vtkMath.Normalize(normalizedX) # The Z axis is an arbitrary vector cross X arbitrary = [0,0,0] for i in range(3): rng.Next() arbitrary[i] = rng.GetRangeValue(-10, 10) vtk.vtkMath.Cross(normalizedX, arbitrary, normalizedZ) vtk.vtkMath.Normalize(normalizedZ) # The Y axis is Z cross X vtk.vtkMath.Cross(normalizedZ, normalizedX, normalizedY) matrix = vtk.vtkMatrix4x4() # Create the direction cosine matrix matrix.Identity() for i in range(3): matrix.SetElement(i, 0, normalizedX[i]) matrix.SetElement(i, 1, normalizedY[i]) matrix.SetElement(i, 2, normalizedZ[i]) # Apply the transforms transform = vtk.vtkTransform() transform.Translate(startPoint) transform.Concatenate(matrix) transform.Scale(length, length, length) # Transform the polydata transformPD = vtk.vtkTransformPolyDataFilter() transformPD.SetTransform(transform) transformPD.SetInputConnection(arrowSource.GetOutputPort()) # Create a mapper and actor for the arrow mapper = vtk.vtkPolyDataMapper() actor = vtk.vtkActor() if (USER_MATRIX): mapper.SetInputConnection(arrowSource.GetOutputPort()) actor.SetUserMatrix(transform.GetMatrix()) else: mapper.SetInputConnection(transformPD.GetOutputPort()) actor.SetMapper(mapper) actor.GetProperty().SetColor(colors.GetColor3d("Cyan")) # Create spheres for start and end point sphereStartSource = vtk.vtkSphereSource() sphereStartSource.SetCenter(startPoint) sphereStartSource.SetRadius(0.8) sphereStartMapper = vtk.vtkPolyDataMapper() sphereStartMapper.SetInputConnection(sphereStartSource.GetOutputPort()) sphereStart = vtk.vtkActor() sphereStart.SetMapper(sphereStartMapper) sphereStart.GetProperty().SetColor(colors.GetColor3d("Yellow")) sphereEndSource = vtk.vtkSphereSource() sphereEndSource.SetCenter(endPoint) sphereEndSource.SetRadius(0.8) sphereEndMapper = vtk.vtkPolyDataMapper() sphereEndMapper.SetInputConnection(sphereEndSource.GetOutputPort()) sphereEnd = vtk.vtkActor() sphereEnd.SetMapper(sphereEndMapper) sphereEnd.GetProperty().SetColor(colors.GetColor3d("Magenta")) # Create a renderer, render window, and interactor renderer = vtk.vtkRenderer() renderWindow = vtk.vtkRenderWindow() renderWindow.AddRenderer(renderer) renderWindow.SetSize(640, 480) renderWindow.SetWindowName("Oriented Arrow") style = vtk.vtkInteractorStyleTrackballCamera() renderWindowInteractor = vtk.vtkRenderWindowInteractor() renderWindowInteractor.SetRenderWindow(renderWindow) renderWindowInteractor.SetInteractorStyle(style) # Add the actor to the scene renderer.AddActor(actor) renderer.AddActor(sphereStart) renderer.AddActor(sphereEnd) renderer.SetBackground(backgroundColor) # Render and interact renderWindow.Render() renderer.GetActiveCamera().Azimuth(30) renderer.GetActiveCamera().Elevation(30) renderer.GetActiveCamera().Roll(30) renderer.ResetCameraClippingRange() renderWindowInteractor.Start() writer = vtk.vtkGLTFExporter() writer.SetFileName(argv[1]) writer.InlineDataOn() writer.SetRenderWindow(renderWindow) writer.Write() return 0
def main(): colors = vtk.vtkNamedColors() # Generate a 10 x 10 grid of points points = vtk.vtkPoints() gridSize = 10 seed = 0 randomSequence = vtk.vtkMinimalStandardRandomSequence() randomSequence.Initialize(seed) for x in range(gridSize): for y in range(gridSize): d1 = randomSequence.GetValue() / 2.0 - 0.25 randomSequence.Next() d2 = randomSequence.GetValue() / 2.0 - 0.25 randomSequence.Next() points.InsertNextPoint(x + d1, y + d2, 0) aPolyData = vtk.vtkPolyData() aPolyData.SetPoints(points) # Create a cell array to store the polygon in aCellArray = vtk.vtkCellArray() # Define a polygonal hole with a clockwise polygon aPolygon = vtk.vtkPolygon() aPolygon.GetPointIds().InsertNextId(22) aPolygon.GetPointIds().InsertNextId(23) aPolygon.GetPointIds().InsertNextId(24) aPolygon.GetPointIds().InsertNextId(25) aPolygon.GetPointIds().InsertNextId(35) aPolygon.GetPointIds().InsertNextId(45) aPolygon.GetPointIds().InsertNextId(44) aPolygon.GetPointIds().InsertNextId(43) aPolygon.GetPointIds().InsertNextId(42) aPolygon.GetPointIds().InsertNextId(32) aCellArray.InsertNextCell(aPolygon) # Create a polydata to store the boundary. The points must be the # same as the points we will triangulate. boundary = vtk.vtkPolyData() boundary.SetPoints(aPolyData.GetPoints()) boundary.SetPolys(aCellArray) # Triangulate the grid points delaunay = vtk.vtkDelaunay2D() delaunay.SetInputData(aPolyData) delaunay.SetSourceData(boundary) # Visualize meshMapper = vtk.vtkPolyDataMapper() meshMapper.SetInputConnection(delaunay.GetOutputPort()) meshActor = vtk.vtkActor() meshActor.SetMapper(meshMapper) meshActor.GetProperty().EdgeVisibilityOn() meshActor.GetProperty().SetEdgeColor(colors.GetColor3d('Peacock')) meshActor.GetProperty().SetInterpolationToFlat() boundaryMapper = vtk.vtkPolyDataMapper() boundaryMapper.SetInputData(boundary) boundaryActor = vtk.vtkActor() boundaryActor.SetMapper(boundaryMapper) boundaryActor.GetProperty().SetColor(colors.GetColor3d('Raspberry')) boundaryActor.GetProperty().SetLineWidth(3) boundaryActor.GetProperty().EdgeVisibilityOn() boundaryActor.GetProperty().SetEdgeColor(colors.GetColor3d('Red')) boundaryActor.GetProperty().SetRepresentationToWireframe() # Create a renderer, render window, and interactor renderer = vtk.vtkRenderer() renderWindow = vtk.vtkRenderWindow() renderWindow.AddRenderer(renderer) renderWindowInteractor = vtk.vtkRenderWindowInteractor() renderWindowInteractor.SetRenderWindow(renderWindow) # Add the actor to the scene renderer.AddActor(meshActor) renderer.AddActor(boundaryActor) renderer.SetBackground(colors.GetColor3d('Mint')) # Render and interact renderWindow.SetSize(640, 480) renderWindow.SetWindowName('ConstrainedDelaunay2D') renderWindow.Render() renderWindowInteractor.Start()
def main(): colors = vtk.vtkNamedColors() # Generate some "random" points. points = vtk.vtkPoints() randomSequence = vtk.vtkMinimalStandardRandomSequence() randomSequence.SetSeed(1) for i in range(0, 50): p1 = randomSequence.GetValue() randomSequence.Next() p2 = randomSequence.GetValue() randomSequence.Next() points.InsertPoint(i, p1, p2, 0.0) # Create a polydata with the points we just created. profile = vtk.vtkPolyData() profile.SetPoints(points) # Perform a 2D Delaunay triangulation on them. delny = vtk.vtkDelaunay2D() delny.SetInputData(profile) delny.SetTolerance(0.001) mapMesh = vtk.vtkPolyDataMapper() mapMesh.SetInputConnection(delny.GetOutputPort()) meshActor = vtk.vtkActor() meshActor.SetMapper(mapMesh) meshActor.GetProperty().SetColor(colors.GetColor3d('MidnightBlue')) # We will now create a nice looking mesh by wrapping the edges in tubes, # and putting fat spheres at the points. extract = vtk.vtkExtractEdges() extract.SetInputConnection(delny.GetOutputPort()) tubes = vtk.vtkTubeFilter() tubes.SetInputConnection(extract.GetOutputPort()) tubes.SetRadius(0.01) tubes.SetNumberOfSides(6) mapEdges = vtk.vtkPolyDataMapper() mapEdges.SetInputConnection(tubes.GetOutputPort()) edgeActor = vtk.vtkActor() edgeActor.SetMapper(mapEdges) edgeActor.GetProperty().SetColor(colors.GetColor3d('peacock')) edgeActor.GetProperty().SetSpecularColor(1, 1, 1) edgeActor.GetProperty().SetSpecular(0.3) edgeActor.GetProperty().SetSpecularPower(20) edgeActor.GetProperty().SetAmbient(0.2) edgeActor.GetProperty().SetDiffuse(0.8) ball = vtk.vtkSphereSource() ball.SetRadius(0.025) ball.SetThetaResolution(12) ball.SetPhiResolution(12) balls = vtk.vtkGlyph3D() balls.SetInputConnection(delny.GetOutputPort()) balls.SetSourceConnection(ball.GetOutputPort()) mapBalls = vtk.vtkPolyDataMapper() mapBalls.SetInputConnection(balls.GetOutputPort()) ballActor = vtk.vtkActor() ballActor.SetMapper(mapBalls) ballActor.GetProperty().SetColor(colors.GetColor3d('hot_pink')) ballActor.GetProperty().SetSpecularColor(1, 1, 1) ballActor.GetProperty().SetSpecular(0.3) ballActor.GetProperty().SetSpecularPower(20) ballActor.GetProperty().SetAmbient(0.2) ballActor.GetProperty().SetDiffuse(0.8) # Create the rendering window, renderer, and interactive renderer. ren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) # Add the actors to the renderer, set the background and size. ren.AddActor(ballActor) ren.AddActor(edgeActor) ren.SetBackground(colors.GetColor3d('AliceBlue')) renWin.SetSize(512, 512) renWin.SetWindowName('DelaunayMesh') ren.ResetCamera() ren.GetActiveCamera().Zoom(1.3) # Interact with the data. iren.Initialize() renWin.Render() iren.Start()
def SST_tel_structure(): l = primary_reflector_diameter / (2 * (2**0.5)) x_points = [l, l, -l, -l] y_points = [-l, l, l, -l] appendFilter = vtk.vtkAppendPolyData() for i in range(4): input1 = vtk.vtkPolyData() # Create a cylinder. # Cylinder height vector is (0,1,0). # Cylinder center is in the middle of the cylinder cylinderSource = vtk.vtkCylinderSource() cylinderSource.SetResolution(15) cylinderSource.SetRadius(0.1) cylinderSource.Update() # Generate a random start and end point startPoint = [x_points[i], y_points[i], 0] endPoint = [x_points[i] / 4, y_points[i] / 4, cam_height] rng = vtk.vtkMinimalStandardRandomSequence() rng.SetSeed(8775070) # For testing. normalizedX = [0, 0, 0] normalizedY = [0, 0, 0] normalizedZ = [0, 0, 0] # The X axis is a vector from start to end vtk.vtkMath.Subtract(endPoint, startPoint, normalizedX) length = vtk.vtkMath.Norm(normalizedX) vtk.vtkMath.Normalize(normalizedX) # The Z axis is an arbitrary vector cross X arbitrary = [0, 0, 0] for i in range(0, 3): rng.Next() arbitrary[i] = rng.GetRangeValue(-10, 10) vtk.vtkMath.Cross(normalizedX, arbitrary, normalizedZ) vtk.vtkMath.Normalize(normalizedZ) # The Y axis is Z cross X vtk.vtkMath.Cross(normalizedZ, normalizedX, normalizedY) matrix = vtk.vtkMatrix4x4() # Create the direction cosine matrix matrix.Identity() for i in range(0, 3): matrix.SetElement(i, 0, normalizedX[i]) matrix.SetElement(i, 1, normalizedY[i]) matrix.SetElement(i, 2, normalizedZ[i]) # Apply the transforms transform = vtk.vtkTransform() transform.Translate(startPoint) # translate to starting point transform.Concatenate(matrix) # apply direction cosines transform.RotateZ(-90.0) # align cylinder to x axis transform.Scale(1.0, length, 1.0) # scale along the height vector transform.Translate(0, .5, 0) # translate to start of cylinder transform.Update() # Transform the polydata transformPD = vtk.vtkTransformPolyDataFilter() transformPD.SetTransform(transform) transformPD.SetInputConnection(cylinderSource.GetOutputPort()) transformPD.Update() input1.ShallowCopy(transformPD.GetOutput()) appendFilter.AddInputData(input1) appendFilter.Update() cleanFilter = vtk.vtkCleanPolyData() cleanFilter.SetInputConnection(appendFilter.GetOutputPort()) cleanFilter.Update() # Create a mapper and actor for the arrow mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(cleanFilter.GetOutputPort()) actor = vtk.vtkActor() actor.SetMapper(mapper) actor.RotateY(90) return actor
def main(): named_colors = vtk.vtkNamedColors() # Create a grid points points = vtk.vtkPoints() GridSize = 20 xx = 0.0 yy = 0.0 zz = 0.0 rng = vtk.vtkMinimalStandardRandomSequence() rng.SetSeed(8775586) # For testing. for x in range(0, GridSize): for y in range(0, GridSize): rng.Next() xx = x + rng.GetRangeValue(-0.2, 0.2) rng.Next() yy = y + rng.GetRangeValue(-0.2, 0.2) rng.Next() zz = rng.GetRangeValue(-0.5, 0.5) points.InsertNextPoint(xx, yy, zz) # Add the grid points to a polydata object inputPolyData = vtk.vtkPolyData() inputPolyData.SetPoints(points) # Triangulate the grid points delaunay = vtk.vtkDelaunay2D() delaunay.SetInputData(inputPolyData) delaunay.Update() outputPolyData = delaunay.GetOutput() bounds = 6 * [0.0] outputPolyData.GetBounds(bounds) # Find min and max z minz = bounds[4] maxz = bounds[5] print('minz: {:< 6.3}'.format(minz)) print('maxz: {:< 6.3}'.format(maxz)) # Create the color map colorLookupTable = vtk.vtkLookupTable() colorLookupTable.SetTableRange(minz, maxz) colorLookupTable.Build() # Generate the colors for each point based on the color map colors = vtk.vtkUnsignedCharArray() colors.SetNumberOfComponents(3) colors.SetName('Colors') print('There are ' + str(outputPolyData.GetNumberOfPoints()) + ' points.') for i in range(0, outputPolyData.GetNumberOfPoints()): p = 3 * [0.0] outputPolyData.GetPoint(i, p) dcolor = 3 * [0.0] colorLookupTable.GetColor(p[2], dcolor) # print( 'dcolor: {:<8.6} {:<8.6} {:<8.6}'.format(*dcolor)) color = 3 * [0.0] for j in range(0, 3): color[j] = int(255.0 * dcolor[j]) # print('color: {:<8} {:<8} {:<8}'.format(*color)) try: colors.InsertNextTupleValue(color) except AttributeError: # For compatibility with new VTK generic data arrays. colors.InsertNextTypedTuple(color) outputPolyData.GetPointData().SetScalars(colors) # Create a mapper and actor mapper = vtk.vtkPolyDataMapper() mapper.SetInputData(outputPolyData) actor = vtk.vtkActor() actor.SetMapper(mapper) # Create a renderer, render window, and interactor renderer = vtk.vtkRenderer() renderWindow = vtk.vtkRenderWindow() renderWindow.AddRenderer(renderer) renderWindow.SetWindowName('ColoredElevationMap') renderWindowInteractor = vtk.vtkRenderWindowInteractor() renderWindowInteractor.SetRenderWindow(renderWindow) # Add the actor to the scene renderer.AddActor(actor) renderer.SetBackground(named_colors.GetColor3d('DarkSlateGray')) # Render and interact renderWindow.Render() renderWindowInteractor.Start()
def main(): cellName = get_program_parameters() # Store the cell class names in a dictionary. cellMap = dict() cellMap[vtk.vtkCellTypes.GetClassNameFromTypeId( vtk.VTK_LINE)] = vtk.VTK_LINE cellMap[vtk.vtkCellTypes.GetClassNameFromTypeId( vtk.VTK_QUADRATIC_EDGE)] = vtk.VTK_QUADRATIC_EDGE cellMap[vtk.vtkCellTypes.GetClassNameFromTypeId( vtk.VTK_CUBIC_LINE)] = vtk.VTK_CUBIC_LINE cellMap[vtk.vtkCellTypes.GetClassNameFromTypeId( vtk.VTK_TRIANGLE)] = vtk.VTK_TRIANGLE cellMap[vtk.vtkCellTypes.GetClassNameFromTypeId( vtk.VTK_QUADRATIC_TRIANGLE)] = vtk.VTK_QUADRATIC_TRIANGLE cellMap[vtk.vtkCellTypes.GetClassNameFromTypeId( vtk.VTK_QUAD)] = vtk.VTK_QUAD cellMap[vtk.vtkCellTypes.GetClassNameFromTypeId( vtk.VTK_QUADRATIC_QUAD)] = vtk.VTK_QUADRATIC_QUAD cellMap[vtk.vtkCellTypes.GetClassNameFromTypeId( vtk.VTK_TETRA)] = vtk.VTK_TETRA cellMap[vtk.vtkCellTypes.GetClassNameFromTypeId( vtk.VTK_HEXAHEDRON)] = vtk.VTK_HEXAHEDRON cellMap[vtk.vtkCellTypes.GetClassNameFromTypeId( vtk.VTK_WEDGE)] = vtk.VTK_WEDGE cellMap[vtk.vtkCellTypes.GetClassNameFromTypeId( vtk.VTK_PYRAMID)] = vtk.VTK_PYRAMID cellMap[vtk.vtkCellTypes.GetClassNameFromTypeId( vtk.VTK_QUADRATIC_WEDGE)] = vtk.VTK_QUADRATIC_WEDGE cellMap[vtk.vtkCellTypes.GetClassNameFromTypeId( vtk.VTK_QUADRATIC_PYRAMID)] = vtk.VTK_QUADRATIC_PYRAMID cellMap[vtk.vtkCellTypes.GetClassNameFromTypeId( vtk.VTK_QUADRATIC_HEXAHEDRON)] = vtk.VTK_QUADRATIC_HEXAHEDRON cellMap[vtk.vtkCellTypes.GetClassNameFromTypeId( vtk.VTK_QUADRATIC_TETRA)] = vtk.VTK_QUADRATIC_TETRA if cellName not in cellMap: print('Cell type ', cellName, ' is not supported.') return source = vtk.vtkCellTypeSource() source.SetCellType(cellMap[cellName]) source.Update() print('Cell: ', cellName) originalPoints = source.GetOutput().GetPoints() points = vtk.vtkPoints() points.SetNumberOfPoints(source.GetOutput().GetNumberOfPoints()) rng = vtk.vtkMinimalStandardRandomSequence() rng.SetSeed(5070) # for testing for i in range(0, points.GetNumberOfPoints()): perturbation = [0.0] * 3 for j in range(0, 3): rng.Next() perturbation[j] = rng.GetRangeValue(-0.1, 0.1) currentPoint = [0.0] * 3 originalPoints.GetPoint(i, currentPoint) points.SetPoint(i, currentPoint[0] + perturbation[0], currentPoint[1] + perturbation[1], currentPoint[2] + perturbation[2]) source.GetOutput().SetPoints(points) numCells = source.GetOutput().GetNumberOfCells() print('Number of cells: ', numCells) idArray = vtk.vtkIntArray() idArray.SetNumberOfTuples(numCells) for i in range(0, numCells): idArray.InsertTuple1(i, i + 1) idArray.SetName('Ids') source.GetOutput().GetCellData().AddArray(idArray) source.GetOutput().GetCellData().SetActiveScalars('Ids') shrink = vtk.vtkShrinkFilter() shrink.SetInputConnection(source.GetOutputPort()) shrink.SetShrinkFactor(.8) tessellate = vtk.vtkTessellatorFilter() tessellate.SetInputConnection(shrink.GetOutputPort()) tessellate.SetMaximumNumberOfSubdivisions(3) # Create a lookup table to map cell data to colors. lut = vtk.vtkLookupTable() colorSeries = vtk.vtkColorSeries() seriesEnum = colorSeries.BREWER_QUALITATIVE_SET3 colorSeries.SetColorScheme(seriesEnum) colorSeries.BuildLookupTable(lut, colorSeries.ORDINAL) # Fill in a few known colors, the rest will be generated if needed. colors = vtk.vtkNamedColors() # Create a mapper and actor. mapper = vtk.vtkDataSetMapper() mapper.SetInputConnection(source.GetOutputPort()) mapper.SetInputConnection(shrink.GetOutputPort()) mapper.SetScalarRange(0, numCells + 1) mapper.SetLookupTable(lut) mapper.SetScalarModeToUseCellData() mapper.SetResolveCoincidentTopologyToPolygonOffset() if (source.GetCellType() == vtk.VTK_QUADRATIC_PYRAMID or source.GetCellType() == vtk.VTK_QUADRATIC_WEDGE): mapper.SetInputConnection(shrink.GetOutputPort()) else: mapper.SetInputConnection(tessellate.GetOutputPort()) actor = vtk.vtkActor() actor.SetMapper(mapper) actor.GetProperty().EdgeVisibilityOn() # actor.GetProperty().SetLineWidth(3) textProperty = vtk.vtkTextProperty() textProperty.SetFontSize(20) textProperty.SetJustificationToCentered() textProperty.SetColor(colors.GetColor3d('Lamp_Black')) textMapper = vtk.vtkTextMapper() textMapper.SetInput(cellName) textMapper.SetTextProperty(textProperty) textActor = vtk.vtkActor2D() textActor.SetMapper(textMapper) textActor.SetPosition(320, 20) # Create a renderer, render window, and interactor. renderer = vtk.vtkRenderer() renderWindow = vtk.vtkRenderWindow() renderWindow.SetWindowName('CellTypeSource') renderWindow.AddRenderer(renderer) renderWindowInteractor = vtk.vtkRenderWindowInteractor() renderWindowInteractor.SetRenderWindow(renderWindow) # Add the actors to the scene. renderer.AddViewProp(textActor) renderer.AddActor(actor) renderer.SetBackground(colors.GetColor3d('Silver')) renderer.ResetCamera() renderer.GetActiveCamera().Azimuth(30) renderer.GetActiveCamera().Elevation(30) renderer.ResetCameraClippingRange() # Render and interact. renderWindow.SetSize(640, 480) renderWindow.Render() renderWindowInteractor.Start()
def main(): maxPucks = 20 if not verify_parameters(maxPucks): return colors = vtk.vtkNamedColors() # Create the renderer and render window interactor. ren = vtk.vtkRenderer() renWin.AddRenderer(ren) renWin.SetSize(1200, 750) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) ren.SetBackground(colors.GetColor3d("PapayaWhip")) camera = vtk.vtkCamera() camera.SetPosition(41.0433, 27.9637, 30.442) camera.SetFocalPoint(11.5603, -1.51931, 0.95899) camera.SetClippingRange(18.9599, 91.6042) camera.SetViewUp(0, 1, 0) ren.SetActiveCamera(camera) # Create geometry: table, pegs, and pucks. pegGeometry = vtk.vtkCylinderSource() pegGeometry.SetResolution(8) pegMapper = vtk.vtkPolyDataMapper() pegMapper.SetInputConnection(pegGeometry.GetOutputPort()) puckGeometry = vtk.vtkCylinderSource() puckGeometry.SetResolution(gv.puckResolution) puckMapper = vtk.vtkPolyDataMapper() puckMapper.SetInputConnection(puckGeometry.GetOutputPort()) tableGeometry = vtk.vtkPlaneSource() tableGeometry.SetResolution(10, 10) tableMapper = vtk.vtkPolyDataMapper() tableMapper.SetInputConnection(tableGeometry.GetOutputPort()) # Create the actors: table top, pegs, and pucks # The table table = vtk.vtkActor() ren.AddActor(table) table.SetMapper(tableMapper) # table.GetProperty().SetColor(0.9569, 0.6431, 0.3765) table.GetProperty().SetColor(colors.GetColor3d("SaddleBrown")) table.AddPosition(gv.D, 0, 0) table.SetScale(4 * gv.D, 2 * gv.D, 3 * gv.D) table.RotateX(90) # The pegs (using cylinder geometry). Note that the pegs have to translated # in the y-direction because the cylinder is centered about the origin. gv.H = 1.1 * gv.numberOfPucks * gv.L peg = list() for i in range(0, 3): peg.append(vtk.vtkActor()) ren.AddActor(peg[i]) peg[i].SetMapper(pegMapper) # peg[i].GetProperty().SetColor(1, 1, 1) peg[i].GetProperty().SetColor(colors.GetColor3d("Lavender")) peg[i].AddPosition(i * gv.D, gv.H / 2, 0) peg[i].SetScale(1, gv.H, 1) # The pucks (using cylinder geometry). Always loaded on peg# 0. puck = list() randomSequence = vtk.vtkMinimalStandardRandomSequence() randomSequence.SetSeed(1) for i in range(0, gv.numberOfPucks): puck.append(vtk.vtkActor()) puck[i].SetMapper(puckMapper) color = [0, 0, 0] for j in range(0, 3): color[j] = randomSequence.GetValue() randomSequence.Next() puck[i].GetProperty().SetColor(*color) puck[i].AddPosition(0, i * gv.L + gv.L / 2, 0) scale = gv.rMax - i * (gv.rMax - gv.rMin) / (gv.numberOfPucks - 1) puck[i].SetScale(scale, 1, scale) ren.AddActor(puck[i]) pegStack[0].append(puck[i]) # Reset the camera to view all actors. renWin.Render() renWin.SetWindowName("Towers of Hanoi") if gv.configuration == 3: WriteImage("hanoi0.png", renWin, rgba=False) if gv.configuration != 1: # Begin recursion. Hanoi(gv.numberOfPucks - 1, 0, 2, 1) Hanoi(1, 0, 1, 2) if not gv.gotFigure2: Hanoi(gv.numberOfPucks - 1, 2, 1, 0) renWin.Render() if gv.configuration == 3: WriteImage("hanoi2.png", renWin, rgba=False) # Report output. s = 'Number of moves: {:d}\nPolygons rendered each frame: {:d}\nTotal number of frames: {:d}' print( s.format(gv.numberOfMoves, 3 * 8 + 1 + gv.numberOfPucks * (2 + gv.puckResolution), gv.numberOfMoves * 3 * gv.numberOfSteps)) iren.AddObserver('EndInteractionEvent', OrientationObserver(ren.GetActiveCamera())) # Render the image. iren.Initialize() iren.Start()
def _plotInternal(self): """Overrides baseclass implementation.""" # Preserve time and z axis for plotting these inof in rendertemplate projection = vcs.elements["projection"][self._gm.projection] taxis = self._originalData1.getTime() if self._originalData1.ndim > 2: zaxis = self._originalData1.getAxis(-3) else: zaxis = None # Streamline color if (not self._gm.coloredbyvector): ln_tmp = self._gm.linetype if ln_tmp is None: ln_tmp = "default" try: ln_tmp = vcs.getline(ln_tmp) lwidth = ln_tmp.width[0] # noqa lcolor = ln_tmp.color[0] lstyle = ln_tmp.type[0] # noqa except Exception: lstyle = "solid" # noqa lwidth = 1. # noqa lcolor = [0., 0., 0., 100.] if self._gm.linewidth is not None: lwidth = self._gm.linewidth # noqa if self._gm.linecolor is not None: lcolor = self._gm.linecolor self._vtkPolyDataFilter.Update() polydata = self._vtkPolyDataFilter.GetOutput() dataLength = polydata.GetLength() if (not self._gm.evenlyspaced): # generate random seeds in a circle centered in the center of # the bounding box for the data. # by default vtkPointSource uses a global random source in vtkMath which is # seeded only once. It makes more sense to seed a random sequence each time you draw # the streamline plot. pointSequence = vtk.vtkMinimalStandardRandomSequence() pointSequence.SetSeedOnly(1177) # replicate the seed from vtkMath seed = vtk.vtkPointSource() seed.SetNumberOfPoints(self._gm.numberofseeds) seed.SetCenter(polydata.GetCenter()) seed.SetRadius(dataLength / 2.0) seed.SetRandomSequence(pointSequence) seed.Update() seedData = seed.GetOutput() # project all points to Z = 0 plane points = seedData.GetPoints() for i in range(0, points.GetNumberOfPoints()): p = list(points.GetPoint(i)) p[2] = 0 points.SetPoint(i, p) if (self._gm.integratortype == 0): integrator = vtk.vtkRungeKutta2() elif (self._gm.integratortype == 1): integrator = vtk.vtkRungeKutta4() else: if (self._gm.evenlyspaced): warnings.warn( "You cannot use RungeKutta45 for evenly spaced streamlines." "Using RungeKutta4 instead") integrator = vtk.vtkRungeKutta4() else: integrator = vtk.vtkRungeKutta45() if (self._gm.evenlyspaced): streamer = vtk.vtkEvenlySpacedStreamlines2D() streamer.SetStartPosition(self._gm.startseed) streamer.SetSeparatingDistance(self._gm.separatingdistance) streamer.SetSeparatingDistanceRatio( self._gm.separatingdistanceratio) streamer.SetClosedLoopMaximumDistance( self._gm.closedloopmaximumdistance) else: # integrate streamlines on normalized vector so that # IntegrationTime stores distance streamer = vtk.vtkStreamTracer() streamer.SetSourceData(seedData) streamer.SetIntegrationDirection(self._gm.integrationdirection) streamer.SetMinimumIntegrationStep(self._gm.minimumsteplength) streamer.SetMaximumIntegrationStep(self._gm.maximumsteplength) streamer.SetMaximumError(self._gm.maximumerror) streamer.SetMaximumPropagation(dataLength * self._gm.maximumstreamlinelength) streamer.SetInputData(polydata) streamer.SetInputArrayToProcess(0, 0, 0, 0, "vector") streamer.SetIntegrationStepUnit(self._gm.integrationstepunit) streamer.SetInitialIntegrationStep(self._gm.initialsteplength) streamer.SetMaximumNumberOfSteps(self._gm.maximumsteps) streamer.SetTerminalSpeed(self._gm.terminalspeed) streamer.SetIntegrator(integrator) # add arc_length to streamlines arcLengthFilter = vtk.vtkAppendArcLength() arcLengthFilter.SetInputConnection(streamer.GetOutputPort()) arcLengthFilter.Update() streamlines = arcLengthFilter.GetOutput() # glyph seed points contour = vtk.vtkContourFilter() contour.SetInputConnection(arcLengthFilter.GetOutputPort()) contour.SetValue(0, 0.001) if (streamlines.GetNumberOfPoints()): r = streamlines.GetPointData().GetArray("arc_length").GetRange() numberofglyphsoneside = self._gm.numberofglyphs // 2 for i in range(1, numberofglyphsoneside): contour.SetValue(i, r[1] / numberofglyphsoneside * i) else: warnings.warn( "No streamlines created. " "The 'startseed' parameter needs to be inside the domain and " "not over masked data.") contour.SetInputArrayToProcess(0, 0, 0, 0, "arc_length") # arrow glyph source glyph2DSource = vtk.vtkGlyphSource2D() glyph2DSource.SetGlyphTypeToTriangle() glyph2DSource.SetRotationAngle(-90) glyph2DSource.SetFilled(self._gm.filledglyph) # arrow glyph adjustment transform = vtk.vtkTransform() transform.Scale(1., self._gm.glyphbasefactor, 1.) transformFilter = vtk.vtkTransformFilter() transformFilter.SetInputConnection(glyph2DSource.GetOutputPort()) transformFilter.SetTransform(transform) transformFilter.Update() glyphLength = transformFilter.GetOutput().GetLength() # drawing the glyphs at the seed points glyph = vtk.vtkGlyph2D() glyph.SetInputConnection(contour.GetOutputPort()) glyph.SetInputArrayToProcess(1, 0, 0, 0, "vector") glyph.SetSourceData(transformFilter.GetOutput()) glyph.SetScaleModeToDataScalingOff() glyph.SetScaleFactor(dataLength * self._gm.glyphscalefactor / glyphLength) glyph.SetColorModeToColorByVector() glyphMapper = vtk.vtkPolyDataMapper() glyphMapper.SetInputConnection(glyph.GetOutputPort()) glyphActor = vtk.vtkActor() glyphActor.SetMapper(glyphMapper) mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(streamer.GetOutputPort()) act = vtk.vtkActor() act.SetMapper(mapper) # color the streamlines and glyphs cmap = self.getColorMap() if (self._gm.coloredbyvector): numLevels = len(self._contourLevels) - 1 while len(self._contourColors) < numLevels: self._contourColors.append(self._contourColors[-1]) lut = vtk.vtkLookupTable() lut.SetNumberOfTableValues(numLevels) for i in range(numLevels): r, g, b, a = self.getColorIndexOrRGBA(cmap, self._contourColors[i]) lut.SetTableValue(i, r / 100., g / 100., b / 100., a / 100.) lut.SetVectorModeToMagnitude() if numpy.allclose(self._contourLevels[0], -1.e20): lmn = self._vectorRange[0] else: lmn = self._contourLevels[0][0] if numpy.allclose(self._contourLevels[-1], 1.e20): lmx = self._vectorRange[1] else: lmx = self._contourLevels[-1][-1] lut.SetRange(lmn, lmx) mapper.ScalarVisibilityOn() mapper.SetLookupTable(lut) mapper.UseLookupTableScalarRangeOn() mapper.SetScalarModeToUsePointFieldData() mapper.SelectColorArray("vector") glyphMapper.ScalarVisibilityOn() glyphMapper.SetLookupTable(lut) glyphMapper.UseLookupTableScalarRangeOn() glyphMapper.SetScalarModeToUsePointFieldData() glyphMapper.SelectColorArray("VectorMagnitude") else: mapper.ScalarVisibilityOff() glyphMapper.ScalarVisibilityOff() if isinstance(lcolor, (list, tuple)): r, g, b, a = lcolor else: r, g, b, a = cmap.index[lcolor] act.GetProperty().SetColor(r / 100., g / 100., b / 100.) glyphActor.GetProperty().SetColor(r / 100., g / 100., b / 100.) plotting_dataset_bounds = self.getPlottingBounds() vp = self._resultDict.get('ratio_autot_viewport', [ self._template.data.x1, self._template.data.x2, self._template.data.y1, self._template.data.y2 ]) dataset_renderer, xScale, yScale = self._context().fitToViewport( act, vp, wc=plotting_dataset_bounds, geoBounds=self._vtkDataSetBoundsNoMask, geo=self._vtkGeoTransform, priority=self._template.data.priority, create_renderer=True) glyph_renderer, xScale, yScale = self._context().fitToViewport( glyphActor, vp, wc=plotting_dataset_bounds, geoBounds=self._vtkDataSetBoundsNoMask, geo=self._vtkGeoTransform, priority=self._template.data.priority, create_renderer=False) kwargs = { 'vtk_backend_grid': self._vtkDataSet, 'dataset_bounds': self._vtkDataSetBounds, 'plotting_dataset_bounds': plotting_dataset_bounds, "vtk_dataset_bounds_no_mask": self._vtkDataSetBoundsNoMask, 'vtk_backend_geo': self._vtkGeoTransform } if ('ratio_autot_viewport' in self._resultDict): kwargs["ratio_autot_viewport"] = vp self._resultDict.update(self._context().renderTemplate( self._template, self._data1, self._gm, taxis, zaxis, **kwargs)) if (self._gm.coloredbyvector): self._resultDict.update(self._context().renderColorBar( self._template, self._contourLevels, self._contourColors, None, self.getColorMap())) if self._context().canvas._continents is None: self._useContinents = False if self._useContinents: continents_renderer, xScale, yScale = self._context( ).plotContinents(plotting_dataset_bounds, projection, self._dataWrapModulo, vp, self._template.data.priority, **kwargs) self._resultDict["vtk_backend_actors"] = [[ act, plotting_dataset_bounds ]] self._resultDict["vtk_backend_luts"] = [[None, None]]
def main(): nx, ny, nz = get_program_parameters() colors = vtk.vtkNamedColors() angle = 0 r1 = 50 r2 = 30 centerX = 10.0 centerY = 5.0 points = vtk.vtkPoints() idx = 0 while angle <= 2.0 * vtk.vtkMath.Pi() + (vtk.vtkMath.Pi() / 60.0): points.InsertNextPoint(r1 * math.cos(angle) + centerX, r2 * math.sin(angle) + centerY, 0.0) angle = angle + (vtk.vtkMath.Pi() / 60.0) idx += 1 line = vtk.vtkPolyLine() line.GetPointIds().SetNumberOfIds(idx) for i in range(0, idx): line.GetPointIds().SetId(i, i) lines = vtk.vtkCellArray() lines.InsertNextCell(line) polyData = vtk.vtkPolyData() polyData.SetPoints(points) polyData.SetLines(lines) extrude = vtk.vtkLinearExtrusionFilter() extrude.SetInputData(polyData) extrude.SetExtrusionTypeToNormalExtrusion() extrude.SetVector(nx, ny, nz) extrude.Update() # Create an oriented arrow startPoint = [0.0] * 3 endPoint = [0.0] * 3 startPoint[0] = centerX startPoint[1] = centerY startPoint[2] = 0.0 for i in range(0, 3): endPoint[i] = startPoint[i] + extrude.GetVector()[i] # Compute a basis normalizedX = [0.0] * 3 normalizedY = [0.0] * 3 normalizedZ = [0.0] * 3 # The X axis is a vector from start to end vtk.vtkMath.Subtract(endPoint, startPoint, normalizedX) length = vtk.vtkMath.Norm(normalizedX) vtk.vtkMath.Normalize(normalizedX) rng = vtk.vtkMinimalStandardRandomSequence() rng.SetSeed(8775070) max_r = 10.0 # The Z axis is an arbitrary vector cross X arbitrary = [0.0] * 3 for i in range(0, 3): arbitrary[i] = rng.GetRangeValue(-max_r, max_r) rng.Next() vtk.vtkMath.Cross(normalizedX, arbitrary, normalizedZ) vtk.vtkMath.Normalize(normalizedZ) # The Y axis is Z cross X vtk.vtkMath.Cross(normalizedZ, normalizedX, normalizedY) matrix = vtk.vtkMatrix4x4() # Create the direction cosine matrix matrix.Identity() for i in range(0, 3): matrix.SetElement(i, 0, normalizedX[i]) matrix.SetElement(i, 1, normalizedY[i]) matrix.SetElement(i, 2, normalizedZ[i]) # Apply the transforms transform = vtk.vtkTransform() transform.Translate(startPoint) transform.Concatenate(matrix) transform.Scale(length, length, length) arrowSource = vtk.vtkArrowSource() arrowSource.SetTipResolution(31) arrowSource.SetShaftResolution(21) # Transform the polydata transformPD = vtk.vtkTransformPolyDataFilter() transformPD.SetTransform(transform) transformPD.SetInputConnection(arrowSource.GetOutputPort()) # Create a mapper and actor for the arrow arrowMapper = vtk.vtkPolyDataMapper() arrowMapper.SetInputConnection(transformPD.GetOutputPort()) arrowActor = vtk.vtkActor() arrowActor.SetMapper(arrowMapper) arrowActor.GetProperty().SetColor(colors.GetColor3d("Tomato")) tubes = vtk.vtkTubeFilter() tubes.SetInputData(polyData) tubes.SetRadius(2.0) tubes.SetNumberOfSides(21) lineMapper = vtk.vtkPolyDataMapper() lineMapper.SetInputConnection(tubes.GetOutputPort()) lineActor = vtk.vtkActor() lineActor.SetMapper(lineMapper) lineActor.GetProperty().SetColor(colors.GetColor3d("Peacock")) mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(extrude.GetOutputPort()) actor = vtk.vtkActor() actor.SetMapper(mapper) actor.GetProperty().SetColor(colors.GetColor3d("Banana")) actor.GetProperty().SetOpacity(.7) ren = vtk.vtkRenderer() ren.SetBackground(colors.GetColor3d("SlateGray")) ren.AddActor(actor) ren.AddActor(lineActor) ren.AddActor(arrowActor) renWin = vtk.vtkRenderWindow() renWin.SetWindowName("Elliptical Cylinder Demo") renWin.AddRenderer(ren) renWin.SetSize(600, 600) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) style = vtk.vtkInteractorStyleTrackballCamera() iren.SetInteractorStyle(style) camera = vtk.vtkCamera() camera.SetPosition(0, 1, 0) camera.SetFocalPoint(0, 0, 0) camera.SetViewUp(0, 0, 1) camera.Azimuth(30) camera.Elevation(30) ren.SetActiveCamera(camera) ren.ResetCamera() ren.ResetCameraClippingRange() renWin.Render() iren.Start()
def main(): # A renderer and render window renderer = vtk.vtkRenderer() renderer.SetBackground(colors.GetColor3d('SteelBlue')) renwin = vtk.vtkRenderWindow() renwin.AddRenderer(renderer) renwin.SetSize(640, 480) renwin.SetWindowName('HighlightPickedActor') # An interactor interactor = vtk.vtkRenderWindowInteractor() interactor.SetRenderWindow(renwin) # add the custom style style = MouseInteractorHighLightActor() style.SetDefaultRenderer(renderer) interactor.SetInteractorStyle(style) randomSequence = vtk.vtkMinimalStandardRandomSequence() # randomSequence.SetSeed(1043618065) # randomSequence.SetSeed(5170) randomSequence.SetSeed(8775070) # Add spheres to play with for i in range(NUMBER_OF_SPHERES): source = vtk.vtkSphereSource() # random position and radius x = randomSequence.GetRangeValue(-5.0, 5.0) randomSequence.Next() y = randomSequence.GetRangeValue(-5.0, 5.0) randomSequence.Next() z = randomSequence.GetRangeValue(-5.0, 5.0) randomSequence.Next() radius = randomSequence.GetRangeValue(0.5, 1.0) randomSequence.Next() source.SetRadius(radius) source.SetCenter(x, y, z) source.SetPhiResolution(11) source.SetThetaResolution(21) mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(source.GetOutputPort()) actor = vtk.vtkActor() actor.SetMapper(mapper) r = randomSequence.GetRangeValue(0.4, 1.0) randomSequence.Next() g = randomSequence.GetRangeValue(0.4, 1.0) randomSequence.Next() b = randomSequence.GetRangeValue(0.4, 1.0) randomSequence.Next() actor.GetProperty().SetDiffuseColor(r, g, b) actor.GetProperty().SetDiffuse(.8) actor.GetProperty().SetSpecular(.5) actor.GetProperty().SetSpecularColor(colors.GetColor3d('White')) actor.GetProperty().SetSpecularPower(30.0) renderer.AddActor(actor) # Start interactor.Initialize() renwin.Render() interactor.Start()
def _plotInternal(self): """Overrides baseclass implementation.""" # Preserve time and z axis for plotting these inof in rendertemplate projection = vcs.elements["projection"][self._gm.projection] zaxis, taxis = self.getZandT() # Streamline color if (not self._gm.coloredbyvector): ln_tmp = self._gm.linetype if ln_tmp is None: ln_tmp = "default" try: ln_tmp = vcs.getline(ln_tmp) lwidth = ln_tmp.width[0] # noqa lcolor = ln_tmp.color[0] lstyle = ln_tmp.type[0] # noqa except Exception: lstyle = "solid" # noqa lwidth = 1. # noqa lcolor = [0., 0., 0., 100.] if self._gm.linewidth is not None: lwidth = self._gm.linewidth # noqa if self._gm.linecolor is not None: lcolor = self._gm.linecolor # The unscaled continent bounds were fine in the presence of axis # conversion, so save them here continentBounds = vcs2vtk.computeDrawAreaBounds( self._vtkDataSetBoundsNoMask, self._context_flipX, self._context_flipY) # Only scaling the data in the presence of axis conversion changes # the seed points in any other cases, and thus results in plots # different from the baselines but still fundamentally sound, it # seems. Always scaling the data results in no differences in the # plots between Context2D and the old baselines. # Transform the input data T = vtk.vtkTransform() T.Scale(self._context_xScale, self._context_yScale, 1.) self._vtkDataSetFittedToViewport = vcs2vtk.applyTransformationToDataset( T, self._vtkDataSetFittedToViewport) self._vtkDataSetBoundsNoMask = self._vtkDataSetFittedToViewport.GetBounds( ) polydata = self._vtkDataSetFittedToViewport plotting_dataset_bounds = self.getPlottingBounds() x1, x2, y1, y2 = plotting_dataset_bounds vp = self._resultDict.get('ratio_autot_viewport', [ self._template.data.x1, self._template.data.x2, self._template.data.y1, self._template.data.y2 ]) # view and interactive area view = self._context().contextView area = vtk.vtkInteractiveArea() view.GetScene().AddItem(area) drawAreaBounds = vcs2vtk.computeDrawAreaBounds( self._vtkDataSetBoundsNoMask, self._context_flipX, self._context_flipY) [renWinWidth, renWinHeight] = self._context().renWin.GetSize() geom = vtk.vtkRecti(int(round(vp[0] * renWinWidth)), int(round(vp[2] * renWinHeight)), int(round((vp[1] - vp[0]) * renWinWidth)), int(round((vp[3] - vp[2]) * renWinHeight))) vcs2vtk.configureContextArea(area, drawAreaBounds, geom) dataLength = polydata.GetLength() if (not self._gm.evenlyspaced): # generate random seeds in a circle centered in the center of # the bounding box for the data. # by default vtkPointSource uses a global random source in vtkMath which is # seeded only once. It makes more sense to seed a random sequence each time you draw # the streamline plot. pointSequence = vtk.vtkMinimalStandardRandomSequence() pointSequence.SetSeedOnly(1177) # replicate the seed from vtkMath seed = vtk.vtkPointSource() seed.SetNumberOfPoints(self._gm.numberofseeds) seed.SetCenter(polydata.GetCenter()) seed.SetRadius(dataLength / 2.0) seed.SetRandomSequence(pointSequence) seed.Update() seedData = seed.GetOutput() # project all points to Z = 0 plane points = seedData.GetPoints() for i in range(0, points.GetNumberOfPoints()): p = list(points.GetPoint(i)) p[2] = 0 points.SetPoint(i, p) if (self._gm.integratortype == 0): integrator = vtk.vtkRungeKutta2() elif (self._gm.integratortype == 1): integrator = vtk.vtkRungeKutta4() else: if (self._gm.evenlyspaced): warnings.warn( "You cannot use RungeKutta45 for evenly spaced streamlines." "Using RungeKutta4 instead") integrator = vtk.vtkRungeKutta4() else: integrator = vtk.vtkRungeKutta45() if (self._gm.evenlyspaced): streamer = vtk.vtkEvenlySpacedStreamlines2D() startseed = self._gm.startseed \ if self._gm.startseed else polydata.GetCenter() streamer.SetStartPosition(startseed) streamer.SetSeparatingDistance(self._gm.separatingdistance) streamer.SetSeparatingDistanceRatio( self._gm.separatingdistanceratio) streamer.SetClosedLoopMaximumDistance( self._gm.closedloopmaximumdistance) else: # integrate streamlines on normalized vector so that # IntegrationTime stores distance streamer = vtk.vtkStreamTracer() streamer.SetSourceData(seedData) streamer.SetIntegrationDirection(self._gm.integrationdirection) streamer.SetMinimumIntegrationStep(self._gm.minimumsteplength) streamer.SetMaximumIntegrationStep(self._gm.maximumsteplength) streamer.SetMaximumError(self._gm.maximumerror) streamer.SetMaximumPropagation(dataLength * self._gm.maximumstreamlinelength) streamer.SetInputData(polydata) streamer.SetInputArrayToProcess(0, 0, 0, 0, "vector") streamer.SetIntegrationStepUnit(self._gm.integrationstepunit) streamer.SetInitialIntegrationStep(self._gm.initialsteplength) streamer.SetMaximumNumberOfSteps(self._gm.maximumsteps) streamer.SetTerminalSpeed(self._gm.terminalspeed) streamer.SetIntegrator(integrator) # add arc_length to streamlines arcLengthFilter = vtk.vtkAppendArcLength() arcLengthFilter.SetInputConnection(streamer.GetOutputPort()) arcLengthFilter.Update() streamlines = arcLengthFilter.GetOutput() # glyph seed points contour = vtk.vtkContourFilter() contour.SetInputConnection(arcLengthFilter.GetOutputPort()) contour.SetValue(0, 0.001) if (streamlines.GetNumberOfPoints()): r = streamlines.GetPointData().GetArray("arc_length").GetRange() numberofglyphsoneside = self._gm.numberofglyphs // 2 for i in range(1, numberofglyphsoneside): contour.SetValue(i, r[1] / numberofglyphsoneside * i) else: warnings.warn( "No streamlines created. " "The 'startseed' parameter needs to be inside the domain and " "not over masked data.") contour.SetInputArrayToProcess(0, 0, 0, 0, "arc_length") # arrow glyph source glyph2DSource = vtk.vtkGlyphSource2D() glyph2DSource.SetGlyphTypeToTriangle() glyph2DSource.SetRotationAngle(-90) glyph2DSource.SetFilled(self._gm.filledglyph) # arrow glyph adjustment transform = vtk.vtkTransform() transform.Scale(1., self._gm.glyphbasefactor, 1.) transformFilter = vtk.vtkTransformFilter() transformFilter.SetInputConnection(glyph2DSource.GetOutputPort()) transformFilter.SetTransform(transform) transformFilter.Update() glyphLength = transformFilter.GetOutput().GetLength() # drawing the glyphs at the seed points glyph = vtk.vtkGlyph2D() glyph.SetInputConnection(contour.GetOutputPort()) glyph.SetInputArrayToProcess(1, 0, 0, 0, "vector") glyph.SetSourceData(transformFilter.GetOutput()) glyph.SetScaleModeToDataScalingOff() glyph.SetScaleFactor(dataLength * self._gm.glyphscalefactor / glyphLength) glyph.SetColorModeToColorByVector() glyphMapper = vtk.vtkPolyDataMapper() glyphActor = vtk.vtkActor() mapper = vtk.vtkPolyDataMapper() act = vtk.vtkActor() glyph.Update() glyphDataset = glyph.GetOutput() streamer.Update() lineDataset = streamer.GetOutput() deleteLineColors = False deleteGlyphColors = False # color the streamlines and glyphs cmap = self.getColorMap() if (self._gm.coloredbyvector): numLevels = len(self._contourLevels) - 1 while len(self._contourColors) < numLevels: self._contourColors.append(self._contourColors[-1]) lut = vtk.vtkLookupTable() lut.SetNumberOfTableValues(numLevels) for i in range(numLevels): r, g, b, a = self.getColorIndexOrRGBA(cmap, self._contourColors[i]) lut.SetTableValue(i, r / 100., g / 100., b / 100., a / 100.) lut.SetVectorModeToMagnitude() if numpy.allclose(self._contourLevels[0], -1.e20): lmn = self._vectorRange[0] else: lmn = self._contourLevels[0][0] if numpy.allclose(self._contourLevels[-1], 1.e20): lmx = self._vectorRange[1] else: lmx = self._contourLevels[-1][-1] lut.SetRange(lmn, lmx) mapper.ScalarVisibilityOn() mapper.SetLookupTable(lut) mapper.UseLookupTableScalarRangeOn() mapper.SetScalarModeToUsePointFieldData() mapper.SelectColorArray("vector") lineAttrs = lineDataset.GetPointData() lineData = lineAttrs.GetArray("vector") if lineData and numLevels: lineColors = lut.MapScalars(lineData, vtk.VTK_COLOR_MODE_DEFAULT, 0) deleteLineColors = True else: print( 'WARNING: streamline pipeline cannot map scalars for "lineData", using solid color' ) numTuples = lineDataset.GetNumberOfPoints() color = [0, 0, 0, 255] lineColors = vcs2vtk.generateSolidColorArray(numTuples, color) glyphMapper.ScalarVisibilityOn() glyphMapper.SetLookupTable(lut) glyphMapper.UseLookupTableScalarRangeOn() glyphMapper.SetScalarModeToUsePointFieldData() glyphMapper.SelectColorArray("VectorMagnitude") glyphAttrs = glyphDataset.GetPointData() glyphData = glyphAttrs.GetArray("VectorMagnitude") if glyphData and numLevels: glyphColors = lut.MapScalars(glyphData, vtk.VTK_COLOR_MODE_DEFAULT, 0) deleteGlyphColors = True else: print( 'WARNING: streamline pipeline cannot map scalars for "glyphData", using solid color' ) numTuples = glyphDataset.GetNumberOfPoints() color = [0, 0, 0, 255] glyphColors = vcs2vtk.generateSolidColorArray(numTuples, color) else: mapper.ScalarVisibilityOff() glyphMapper.ScalarVisibilityOff() if isinstance(lcolor, (list, tuple)): r, g, b, a = lcolor else: r, g, b, a = cmap.index[lcolor] act.GetProperty().SetColor(r / 100., g / 100., b / 100.) glyphActor.GetProperty().SetColor(r / 100., g / 100., b / 100.) fixedColor = [ int((r / 100.) * 255), int((g / 100.) * 255), int((b / 100.) * 255), 255 ] numTuples = lineDataset.GetNumberOfPoints() lineColors = vcs2vtk.generateSolidColorArray(numTuples, fixedColor) numTuples = glyphDataset.GetNumberOfPoints() glyphColors = vcs2vtk.generateSolidColorArray( numTuples, fixedColor) # Add the streamlines lineItem = vtk.vtkPolyDataItem() lineItem.SetPolyData(lineDataset) lineItem.SetScalarMode(vtk.VTK_SCALAR_MODE_USE_POINT_DATA) lineItem.SetMappedColors(lineColors) if deleteLineColors: lineColors.FastDelete() area.GetDrawAreaItem().AddItem(lineItem) # Add the glyphs glyphItem = vtk.vtkPolyDataItem() glyphItem.SetPolyData(glyphDataset) glyphItem.SetScalarMode(vtk.VTK_SCALAR_MODE_USE_POINT_DATA) glyphItem.SetMappedColors(glyphColors) if deleteGlyphColors: glyphColors.FastDelete() area.GetDrawAreaItem().AddItem(glyphItem) plotting_dataset_bounds = self.getPlottingBounds() vp = self._resultDict.get('ratio_autot_viewport', [ self._template.data.x1, self._template.data.x2, self._template.data.y1, self._template.data.y2 ]) kwargs = { 'vtk_backend_grid': self._vtkDataSet, 'dataset_bounds': self._vtkDataSetBounds, 'plotting_dataset_bounds': plotting_dataset_bounds, "vtk_dataset_bounds_no_mask": self._vtkDataSetBoundsNoMask, 'vtk_backend_geo': self._vtkGeoTransform, "vtk_backend_draw_area_bounds": continentBounds, "vtk_backend_viewport_scale": [self._context_xScale, self._context_yScale] } if ('ratio_autot_viewport' in self._resultDict): kwargs["ratio_autot_viewport"] = vp self._resultDict.update(self._context().renderTemplate( self._template, self._data1, self._gm, taxis, zaxis, **kwargs)) if (self._gm.coloredbyvector): self._resultDict.update(self._context().renderColorBar( self._template, self._contourLevels, self._contourColors, None, self.getColorMap())) kwargs['xaxisconvert'] = self._gm.xaxisconvert kwargs['yaxisconvert'] = self._gm.yaxisconvert if self._data1.getAxis(-1).isLongitude() and self._data1.getAxis( -2).isLatitude(): self._context().plotContinents( self._plot_kargs.get("continents", self._useContinents), plotting_dataset_bounds, projection, self._dataWrapModulo, vp, self._template.data.priority, **kwargs) self._resultDict["vtk_backend_actors"] = [[ lineItem, plotting_dataset_bounds ]] self._resultDict["vtk_backend_luts"] = [[None, None]]
def main(): colors = vtk.vtkNamedColors() # Set the background color. colors.SetColor("BkgColor", [26, 51, 77, 255]) # Create a cylinder. # Cylinder height vector is (0,1,0). # Cylinder center is in the middle of the cylinder cylinderSource = vtk.vtkCylinderSource() cylinderSource.SetResolution(15) # Generate a random start and end point startPoint = [0] * 3 endPoint = [0] * 3 rng = vtk.vtkMinimalStandardRandomSequence() rng.SetSeed(8775070) # For testing. for i in range(0, 3): rng.Next() startPoint[i] = rng.GetRangeValue(-10, 10) rng.Next() endPoint[i] = rng.GetRangeValue(-10, 10) # Compute a basis normalizedX = [0] * 3 normalizedY = [0] * 3 normalizedZ = [0] * 3 # The X axis is a vector from start to end vtk.vtkMath.Subtract(endPoint, startPoint, normalizedX) length = vtk.vtkMath.Norm(normalizedX) vtk.vtkMath.Normalize(normalizedX) # The Z axis is an arbitrary vector cross X arbitrary = [0] * 3 for i in range(0, 3): rng.Next() arbitrary[i] = rng.GetRangeValue(-10, 10) vtk.vtkMath.Cross(normalizedX, arbitrary, normalizedZ) vtk.vtkMath.Normalize(normalizedZ) # The Y axis is Z cross X vtk.vtkMath.Cross(normalizedZ, normalizedX, normalizedY) matrix = vtk.vtkMatrix4x4() # Create the direction cosine matrix matrix.Identity() for i in range(0, 3): matrix.SetElement(i, 0, normalizedX[i]) matrix.SetElement(i, 1, normalizedY[i]) matrix.SetElement(i, 2, normalizedZ[i]) # Apply the transforms transform = vtk.vtkTransform() transform.Translate(startPoint) # translate to starting point transform.Concatenate(matrix) # apply direction cosines transform.RotateZ(-90.0) # align cylinder to x axis transform.Scale(1.0, length, 1.0) # scale along the height vector transform.Translate(0, .5, 0) # translate to start of cylinder # Transform the polydata transformPD = vtk.vtkTransformPolyDataFilter() transformPD.SetTransform(transform) transformPD.SetInputConnection(cylinderSource.GetOutputPort()) # Create a mapper and actor for the arrow mapper = vtk.vtkPolyDataMapper() actor = vtk.vtkActor() if USER_MATRIX: mapper.SetInputConnection(cylinderSource.GetOutputPort()) actor.SetUserMatrix(transform.GetMatrix()) else: mapper.SetInputConnection(transformPD.GetOutputPort()) actor.SetMapper(mapper) actor.GetProperty().SetColor(colors.GetColor3d("Cyan")) # Create spheres for start and end point sphereStartSource = vtk.vtkSphereSource() sphereStartSource.SetCenter(startPoint) sphereStartSource.SetRadius(0.8) sphereStartMapper = vtk.vtkPolyDataMapper() sphereStartMapper.SetInputConnection(sphereStartSource.GetOutputPort()) sphereStart = vtk.vtkActor() sphereStart.SetMapper(sphereStartMapper) sphereStart.GetProperty().SetColor(colors.GetColor3d("Yellow")) sphereEndSource = vtk.vtkSphereSource() sphereEndSource.SetCenter(endPoint) sphereEndSource.SetRadius(0.8) sphereEndMapper = vtk.vtkPolyDataMapper() sphereEndMapper.SetInputConnection(sphereEndSource.GetOutputPort()) sphereEnd = vtk.vtkActor() sphereEnd.SetMapper(sphereEndMapper) sphereEnd.GetProperty().SetColor(colors.GetColor3d("Magenta")) # Create a renderer, render window, and interactor renderer = vtk.vtkRenderer() renderWindow = vtk.vtkRenderWindow() renderWindow.AddRenderer(renderer) renderWindow.SetWindowName("Oriented Cylinder") renderWindowInteractor = vtk.vtkRenderWindowInteractor() renderWindowInteractor.SetRenderWindow(renderWindow) # Add the actor to the scene renderer.AddActor(actor) renderer.AddActor(sphereStart) renderer.AddActor(sphereEnd) renderer.SetBackground(colors.GetColor3d("BkgColor")) # Render and interact renderWindow.Render() renderWindowInteractor.Start()
def main(): numberOfSpheres = get_program_parameters() colors = vtk.vtkNamedColors() # A renderer and render window renderer = vtk.vtkRenderer() renderer.SetBackground(colors.GetColor3d('SteelBlue')) renderWindow = vtk.vtkRenderWindow() renderWindow.SetSize(640, 480) renderWindow.AddRenderer(renderer) # An interactor interactor = vtk.vtkRenderWindowInteractor() interactor.SetRenderWindow(renderWindow) randomSequence = vtk.vtkMinimalStandardRandomSequence() # randomSequence.SetSeed(1043618065) # randomSequence.SetSeed(5170) randomSequence.SetSeed(8775070) # Add spheres to play with for i in range(numberOfSpheres): source = vtk.vtkSphereSource() # random position and radius x = randomSequence.GetRangeValue(-5.0, 5.0) randomSequence.Next() y = randomSequence.GetRangeValue(-5.0, 5.0) randomSequence.Next() z = randomSequence.GetRangeValue(-5.0, 5.0) randomSequence.Next() radius = randomSequence.GetRangeValue(0.5, 1.0) randomSequence.Next() source.SetRadius(radius) source.SetCenter(x, y, z) source.SetPhiResolution(11) source.SetThetaResolution(21) mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(source.GetOutputPort()) actor = vtk.vtkActor() actor.SetMapper(mapper) r = randomSequence.GetRangeValue(0.4, 1.0) randomSequence.Next() g = randomSequence.GetRangeValue(0.4, 1.0) randomSequence.Next() b = randomSequence.GetRangeValue(0.4, 1.0) randomSequence.Next() actor.GetProperty().SetDiffuseColor(r, g, b) actor.GetProperty().SetDiffuse(0.8) actor.GetProperty().SetSpecular(0.5) actor.GetProperty().SetSpecularColor(colors.GetColor3d('White')) actor.GetProperty().SetSpecularPower(30.0) renderer.AddActor(actor) # Render and interact renderWindow.Render() # Create the silhouette pipeline, the input data will be set in the # interactor silhouette = vtk.vtkPolyDataSilhouette() silhouette.SetCamera(renderer.GetActiveCamera()) # Create mapper and actor for silhouette silhouetteMapper = vtk.vtkPolyDataMapper() silhouetteMapper.SetInputConnection(silhouette.GetOutputPort()) silhouetteActor = vtk.vtkActor() silhouetteActor.SetMapper(silhouetteMapper) silhouetteActor.GetProperty().SetColor(colors.GetColor3d("Tomato")) silhouetteActor.GetProperty().SetLineWidth(5) # Set the custom type to use for interaction. style = MouseInteractorHighLightActor(silhouette, silhouetteActor) style.SetDefaultRenderer(renderer) # Start interactor.Initialize() interactor.SetInteractorStyle(style) renderWindow.SetWindowName('HighlightWithSilhouette') renderWindow.Render() interactor.Start()
def main(): colors = vtk.vtkNamedColors() numTuples = 12 bitter = vtk.vtkFloatArray() bitter.SetNumberOfTuples(numTuples) crispy = vtk.vtkFloatArray() crispy.SetNumberOfTuples(numTuples) crunchy = vtk.vtkFloatArray() crunchy.SetNumberOfTuples(numTuples) salty = vtk.vtkFloatArray() salty.SetNumberOfTuples(numTuples) oily = vtk.vtkFloatArray() oily.SetNumberOfTuples(numTuples) rand_seq = vtk.vtkMinimalStandardRandomSequence() rand_seq.SetSeed(8775070) for i in range(numTuples): bitter.SetTuple1(i, rand_seq.GetRangeValue(1, 10)) rand_seq.Next() crispy.SetTuple1(i, rand_seq.GetRangeValue(-1, 1)) rand_seq.Next() crunchy.SetTuple1(i, rand_seq.GetRangeValue(1, 100)) rand_seq.Next() salty.SetTuple1(i, rand_seq.GetRangeValue(0, 10)) rand_seq.Next() oily.SetTuple1(i, rand_seq.GetRangeValue(5, 25)) rand_seq.Next() dobj = vtk.vtkDataObject() dobj.GetFieldData().AddArray(bitter) dobj.GetFieldData().AddArray(crispy) dobj.GetFieldData().AddArray(crunchy) dobj.GetFieldData().AddArray(salty) dobj.GetFieldData().AddArray(oily) actor = vtk.vtkSpiderPlotActor() actor.SetInputData(dobj) actor.SetTitle("Spider Plot") actor.SetIndependentVariablesToColumns() actor.GetPositionCoordinate().SetValue(0.05, 0.1, 0.0) actor.GetPosition2Coordinate().SetValue(0.95, 0.85, 0.0) actor.GetProperty().SetColor(colors.GetColor3d('Red')) actor.SetAxisLabel(0, "Bitter") actor.SetAxisRange(0, 1, 10) actor.SetAxisLabel(1, "Crispy") actor.SetAxisRange(1, -1, 1) actor.SetAxisLabel(2, "Crunchy") actor.SetAxisRange(2, 1, 100) actor.SetAxisLabel(3, "Salty") actor.SetAxisRange(3, 0, 10) actor.SetAxisLabel(4, "Oily") actor.SetAxisRange(4, 5, 25) actor.GetLegendActor().SetNumberOfEntries(numTuples) for i in range(numTuples): r = rand_seq.GetRangeValue(0.4, 1.0) rand_seq.Next() g = rand_seq.GetRangeValue(0.4, 1.0) rand_seq.Next() b = rand_seq.GetRangeValue(0.4, 1.0) rand_seq.Next() actor.SetPlotColor(i, r, g, b) actor.LegendVisibilityOn() actor.GetTitleTextProperty().SetColor(colors.GetColor3d('MistyRose')) actor.GetLabelTextProperty().SetColor(colors.GetColor3d('MistyRose')) ren1 = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren1) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) ren1.AddActor(actor) ren1.SetBackground(colors.GetColor3d('DarkSlateGray')) renWin.SetSize(600, 500) renWin.SetWindowName('SpiderPlot') iren.Initialize() renWin.Render() iren.Start()
def main(): colors = vtk.vtkNamedColors() Pr = 10.0 # The Lorenz parameters b = 2.667 r = 28.0 # x = 0.0 # y = 0.0 # z = 0.0 # starting (and current) x, y, z h = 0.01 # integration step size resolution = 200 # slice resolution iterations = 10000000 # number of iterations xmin = -30.0 # x, y, z range for voxels xmax = 30.0 ymin = -30.0 ymax = 30.0 zmin = -10.0 zmax = 60.0 # Take a stab at an integration step size. xIncr = resolution / (xmax - xmin) yIncr = resolution / (ymax - ymin) zIncr = resolution / (zmax - zmin) print('The Lorenz Attractor\n') print(' Pr =', Pr) print(' b =', b) print(' r =', r) print(' integration step size =', h) print(' slice resolution =', resolution) print(' # of iterations =', iter) print(' specified range:') print(' x: {:f}, {:f}'.format(xmin, xmax)) print(' y: {:f}, {:f}'.format(ymin, ymax)) print(' z: {:f}, {:f}'.format(zmin, zmax)) randomSequence = vtk.vtkMinimalStandardRandomSequence() randomSequence.SetSeed(8775070) x = randomSequence.GetRangeValue(xmin, xmax) randomSequence.Next() y = randomSequence.GetRangeValue(ymin, ymax) randomSequence.Next() z = randomSequence.GetRangeValue(zmin, zmax) randomSequence.Next() print(' starting at {:f}, {:f}, {:f}'.format(x, y, z)) # allocate memory for the slices sliceSize = resolution * resolution numPts = sliceSize * resolution scalars = vtk.vtkShortArray() for i in range(0, numPts): scalars.InsertTuple1(i, 0) for j in range(0, iterations): # Integrate to the next time step. xx = x + h * Pr * (y - x) yy = y + h * (x * (r - z) - y) zz = z + h * (x * y - (b * z)) x = xx y = yy z = zz # Calculate the voxel index. if xmax > x > xmin and ymax > y > ymin and zmax > z > zmin: xxx = int(float(xx - xmin) * xIncr) yyy = int(float(yy - ymin) * yIncr) zzz = int(float(zz - zmin) * zIncr) index = xxx + yyy * resolution + zzz * sliceSize scalars.SetTuple1(index, scalars.GetTuple1(index) + 1) volume = vtk.vtkStructuredPoints() volume.GetPointData().SetScalars(scalars) volume.SetDimensions(resolution, resolution, resolution) volume.SetOrigin(xmin, ymin, zmin) volume.SetSpacing((xmax - xmin) / resolution, (ymax - ymin) / resolution, (zmax - zmin) / resolution) print(' contouring...') # Do the graphics dance. renderer = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(renderer) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) # Create iso-surface contour = vtk.vtkContourFilter() contour.SetInputData(volume) contour.SetValue(0, 50) # Create mapper. mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(contour.GetOutputPort()) mapper.ScalarVisibilityOff() # Create actor. actor = vtk.vtkActor() actor.SetMapper(mapper) actor.GetProperty().SetColor(colors.GetColor3d('DodgerBlue')) renderer.AddActor(actor) renderer.SetBackground(colors.GetColor3d('PaleGoldenrod')) renWin.SetSize(640, 480) # interact with data renWin.Render() renWin.SetWindowName('Lorenz') camera = renderer.GetActiveCamera() camera.SetPosition(-67.645167, -25.714343, 63.483516) camera.SetFocalPoint(3.224902, -4.398594, 29.552112) camera.SetViewUp(-0.232264, 0.965078, 0.121151) camera.SetDistance(81.414176) camera.SetClippingRange(18.428905, 160.896031) iren.Start()