def displayEigenvectors( self, mode=1, setToDisplay=None, fConvUnits=1.0, scaleFactor=1.0, viewDef=vtk_graphic_base.CameraParameters('XYZPos'), fileName=None, defFScale=0.0): self.checkSetToDisp(setToDisplay) preprocessor = setToDisplay.getPreprocessor #auto-scale LrefModSize = self.xcSet.getBnd(1.0).diagonal.getModulus( ) #representative length of set size (to autoscale) maxAbs = 0.0 dispPairs = list() rotPairs = list() threshold = LrefModSize / 1000.0 for n in self.xcSet.nodes: disp3d = n.getEigenvectorDisp3dComponents(mode) rot3d = n.getEigenvectorRot3dComponents(mode) modDisp3d = disp3d.getModulus() if (modDisp3d > threshold): p = n.getCurrentPos3d(defFScale) dispPairs.append(([p.x, p.y, p.z], [disp3d.x, disp3d.y, disp3d.z])) modRot3d = rot3d.getModulus() if (modRot3d > threshold): p = n.getCurrentPos3d(defFScale) rotPairs.append(([p.x, p.y, p.z], [rot3d.x, rot3d.y, rot3d.z])) modR = max(modDisp3d, modRot3d) if (modR > maxAbs): maxAbs = modR if maxAbs > 0: scaleFactor *= 0.15 * LrefModSize / (maxAbs * fConvUnits) # caption = 'Mode ' + str( mode) + ' eigenvectors' + ' ' + self.xcSet.description vFieldD = vf.VectorField(name='Deigenvectors', fUnitConv=fConvUnits, scaleFactor=scaleFactor, showPushing=True, symType=vtk.vtkArrowSource()) #Force vFieldR = vf.VectorField(name='Reigenvectors', fUnitConv=fConvUnits, scaleFactor=scaleFactor, showPushing=True, symType=vtk.vtkArrowSource()) vFieldD.populateFromPairList(dispPairs) vFieldR.populateFromPairList(rotPairs) defDisplay = self.getDisplay(viewDef) defDisplay.setupGrid(self.xcSet) defDisplay.defineMeshScene(None, defFScale, color=self.xcSet.color) if (len(dispPairs) > 0): vFieldD.addToDisplay(defDisplay) if (len(rotPairs) > 0): vFieldR.addToDisplay(defDisplay, 'V') defDisplay.displayScene(caption, fileName)
def displayReactions(self, setToDisplay=None, fConvUnits=1.0, scaleFactor=1.0, unitDescription='', viewDef=vtk_graphic_base.CameraParameters('XYZPos'), fileName=None, defFScale=0.0): self.checkSetToDisp(setToDisplay) preprocessor = setToDisplay.getPreprocessor preprocessor.getNodeHandler.calculateNodalReactions(True, 1e-7) #auto-scale LrefModSize = self.xcSet.getBnd(1.0).diagonal.getModulus( ) #representative length of set size (to autoscale) maxAbs = 0.0 forcePairs = list() momentPairs = list() threshold = LrefModSize / 1000.0 for n in self.xcSet.nodes: f3d = n.getReactionForce3d m3d = n.getReactionMoment3d modF3d = f3d.getModulus() if (modF3d > threshold): p = n.getCurrentPos3d(defFScale) forcePairs.append(([p.x, p.y, p.z], [f3d.x, f3d.y, f3d.z])) modM3d = m3d.getModulus() if (modM3d > threshold): p = n.getCurrentPos3d(defFScale) momentPairs.append(([p.x, p.y, p.z], [m3d.x, m3d.y, m3d.z])) modR = max(modF3d, modF3d) if (modR > maxAbs): maxAbs = modR if (maxAbs > 0): scaleFactor *= 0.15 * LrefModSize / (maxAbs * fConvUnits) # caption = self.loadCaseName + ' Reactions' + ' ' + unitDescription + ' ' + self.xcSet.description vFieldF = vf.VectorField(name='Freact', fUnitConv=fConvUnits, scaleFactor=scaleFactor, showPushing=True, symType=vtk.vtkArrowSource()) # Force vFieldM = vf.VectorField(name='Mreact', fUnitConv=fConvUnits, scaleFactor=scaleFactor, showPushing=True, symType=vtk.vtkArrowSource()) # Moment vFieldF.populateFromPairList(forcePairs) vFieldM.populateFromPairList(momentPairs) defDisplay = self.getDisplay(viewDef) defDisplay.setupGrid(self.xcSet) defDisplay.defineMeshScene(None, defFScale, color=self.xcSet.color) if (len(forcePairs) > 0): vFieldF.addToDisplay(defDisplay) if (len(momentPairs) > 0): vFieldM.addToDisplay(defDisplay, 'V') defDisplay.displayScene(caption, fileName)
def setupGlyph(self,fUnitConv= 1.0): self.polydata= self.getPolydata(fUnitConv) # Generate the arrow for the glyphs arrow = vtk.vtkArrowSource() #arrow.SetRadius(0.1) #arrow.SetHeight(0.5) self.glyph = vtk.vtkGlyph3D() self.glyph.SetInputData(self.polydata) self.glyph.SetSourceConnection(arrow.GetOutputPort()) self.glyph.ScalingOn() self.glyph.SetScaleModeToScaleByScalar() self.glyph.SetVectorModeToUseVector() self.glyph.OrientOn() # Tell the filter to "clamp" the scalar range #self.glyph.ClampingOn() # Set the overall (multiplicative) scaling factor self.glyph.SetScaleFactor(self.scaleFactor) # Set the Range to "clamp" the data to # -- see equations above for nonintuitive definition of "clamping" # The fact that I'm setting the minimum value of the range below # the minimum of my data (real min=0.0) with the equations above # forces a minimum non-zero glyph size. #self.glyph.SetRange(-10, 10) # Change these values to see effect on cone sizes # Tell glyph which attribute arrays to use for what self.glyph.SetInputArrayToProcess(0,0,0,0,self.lenghtsName) # scalars self.glyph.SetInputArrayToProcess(1,0,0,0,self.vectorsName) # vectors # self.glyph.SetInputArrayToProcess(2,0,0,0,'nothing') # normals #self.glyph.SetInputArrayToProcess(3,0,0,0,self.lenghtsName) # colors # Calling update because I'm going to use the scalar range to set the color map range self.glyph.Update()
def _glyph(dataset, scale_mode='scalar', orient=True, scalars=True, factor=1.0, geom=None, tolerance=0.0, absolute=False, clamping=False, rng=None): if geom is None: arrow = vtk.vtkArrowSource() arrow.Update() geom = arrow.GetOutputPort() alg = vtk.vtkGlyph3D() alg.SetSourceConnection(geom) if isinstance(scalars, str): dataset.active_scalars_name = scalars if isinstance(orient, str): dataset.active_vectors_name = orient orient = True if scale_mode == 'scalar': alg.SetScaleModeToScaleByScalar() elif scale_mode == 'vector': alg.SetScaleModeToScaleByVector() else: alg.SetScaleModeToDataScalingOff() if rng is not None: alg.SetRange(rng) alg.SetOrient(orient) alg.SetInputData(dataset) alg.SetScaleFactor(factor) alg.SetClamping(clamping) alg.Update() return alg
def MakeGlyphs(src, normal_reverse, normal_arrowAtPoint): reverse = vtk.vtkReverseSense() maskPts = vtk.vtkMaskPoints() maskPts.SetOnRatio(1) if normal_reverse: reverse.SetInputData(src) reverse.ReverseCellsOn() reverse.ReverseNormalsOn() maskPts.SetInputConnection(reverse.GetOutputPort()) else: maskPts.SetInputData(src) arrow = vtk.vtkArrowSource() if normal_arrowAtPoint: arrow.SetInvert(1) else: arrow.SetInvert(0) arrow.SetTipResolution(16) arrow.SetTipLength(normal_length) arrow.SetTipRadius(normal_tip_radius) glyph = vtk.vtkGlyph3D() glyph.SetSourceConnection(arrow.GetOutputPort()) glyph.SetInputConnection(maskPts.GetOutputPort()) glyph.SetVectorModeToUseNormal() glyph.SetScaleFactor(normal_scale) if normal_scaleByPointScalar: glyph.SetScaleModeToScaleByScalar() else: glyph.SetScaleModeToScaleByVector() glyph.SetColorModeToColorByScalar() glyph.OrientOn() return glyph
def create_glyph(self,plane_mapper): #in here we do the arrows arrows = vtk.vtkArrowSource() ptMask = vtk.vtkMaskPoints() ptMask.SetInputConnection(plane_mapper.GetOutputPort()) ptMask.SetOnRatio(10) ptMask.RandomModeOn() #in here we do the glyohs glyph = vtk.vtkGlyph3D() glyph.SetSourceConnection(arrows.GetOutputPort()) glyph.SetInputConnection(ptMask.GetOutputPort()) glyph.SetColorModeToColorByVector() glyph.SetScaleFactor(20) #Glyph mapper gly_mapper = vtk.vtkPolyDataMapper() gly_mapper.SetInputConnection(glyph.GetOutputPort()) gly_mapper.SetLookupTable(self.arrowColor) #glyph actor gly_actor = vtk.vtkActor() gly_actor.SetMapper(gly_mapper) return gly_actor
def createData(): num_rows = 10 num_cols = 10 num_pts = num_rows * num_cols points = vtk.vtkPoints() points.SetNumberOfPoints(num_pts) lines = vtk.vtkCellArray() lines.InsertNextCell(num_pts+1) n = 0 cx = 10.0 cy = 5.0 dx = 0.1 dy = 0.1 dz = 0.0 for i in range(num_cols): for j in range(num_rows): x = cx + dx*j y = cy + dy*i z = 0.0 points.SetPoint(n, x, y, z) lines.InsertCellPoint(n) n += 1 lines.InsertCellPoint(0) poly = vtk.vtkPolyData() poly.SetPoints(points) poly.SetLines(lines) arrow = vtk.vtkArrowSource() arrow.Update() return poly, arrow
def computeNormals(self, inputNode): # compute normals model = inputNode arrow = vtk.vtkArrowSource() arrow.Update() normals = vtk.vtkPolyDataNormals() normals.SetInputConnection(model.GetPolyDataConnection()) normals.ComputePointNormalsOff() normals.ComputeCellNormalsOn() normals.SplittingOn() normals.FlipNormalsOff() normals.ConsistencyOn() normals.AutoOrientNormalsOn() normals.Update() centers = vtk.vtkCellCenters() centers.SetInputConnection(normals.GetOutputPort()) glyph = vtk.vtkGlyph3D() glyph.SetInputData(normals.GetOutput()) glyph.SetInputConnection(centers.GetOutputPort()) glyph.SetSourceData(arrow.GetOutput()) glyph.SetVectorModeToUseNormal() glyph.SetScaleModeToScaleByVector() glyph.SetScaleFactor(1) glyph.OrientOn() glyph.Update() slicer.modules.models.logic().AddModel(glyph.GetOutput()) normalsNode = slicer.util.getNode('Model') return normalsNode
def __init__ (self, mod_m): debug ("In VelocityVector::__init__ ()") Common.state.busy () Base.Objects.Module.__init__ (self, mod_m) self.glyph2d_src = vtk.vtkGlyphSource2D () self.cone = vtk.vtkConeSource () self.arrow = vtk.vtkArrowSource () self.glyph_src = self.cone self.glyph3d = vtk.vtkGlyph3D () self.mapper = self.map = vtk.vtkPolyDataMapper () self.actor = self.act = vtk.vtkActor () # used to orient the cone properly self.glph_trfm = vtk.vtkTransformFilter () self.glph_trfm.SetTransform (vtk.vtkTransform ()) self.data_out = self.mod_m.GetOutput () # Point of glyph that is attached -- -1 is tail, 0 is center, # 1 is head. self.glyph_pos = -1 self.scale = 1.0 self.color_mode = 2 #2 is vector, 1 is scalar, -1 none self._initialize () self._gui_init () self.renwin.Render () Common.state.idle ()
def setupGlyph(self, fUnitConv=1.0, symType=vtk.vtkArrowSource()): self.polydata = self.getPolydata(fUnitConv) # Generate the arrow for the glyphs self.glyph = vtk.vtkGlyph3D() self.glyph.SetInputData(self.polydata) self.glyph.SetSourceConnection(symType.GetOutputPort()) self.glyph.ScalingOn() self.glyph.SetScaleModeToScaleByScalar() self.glyph.SetVectorModeToUseVector() self.glyph.OrientOn() # Tell the filter to "clamp" the scalar range #self.glyph.ClampingOn() # Set the overall (multiplicative) scaling factor self.glyph.SetScaleFactor(self.scaleFactor) # Set the Range to "clamp" the data to # -- see equations above for nonintuitive definition of "clamping" # The fact that I'm setting the minimum value of the range below # the minimum of my data (real min=0.0) with the equations above # forces a minimum non-zero glyph size. #self.glyph.SetRange(-10, 10) # Change these values to see effect on cone sizes # Tell glyph which attribute arrays to use for what self.glyph.SetInputArrayToProcess(0, 0, 0, 0, self.lenghtsName) # scalars self.glyph.SetInputArrayToProcess(1, 0, 0, 0, self.vectorsName) # vectors # self.glyph.SetInputArrayToProcess(2,0,0,0,'nothing') # normals #self.glyph.SetInputArrayToProcess(3,0,0,0,self.lenghtsName) # colors # Calling update because I'm going to use the scalar range to set the color map range self.glyph.Update()
def main(): colors = vtk.vtkNamedColors() arrowSource = vtk.vtkArrowSource() # arrowSource.SetShaftRadius(0.01) # arrowSource.SetTipLength(.9) # Create a mapper and actor mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(arrowSource.GetOutputPort()) actor = vtk.vtkActor() actor.SetMapper(mapper) # Visualize renderer = vtk.vtkRenderer() renderWindow = vtk.vtkRenderWindow() renderWindow.SetWindowName("Arrow") renderWindow.AddRenderer(renderer) renderWindowInteractor = vtk.vtkRenderWindowInteractor() renderWindowInteractor.SetRenderWindow(renderWindow) renderer.AddActor(actor) renderer.SetBackground(colors.GetColor3d("MidnightBlue")) renderWindow.Render() renderWindowInteractor.Start()
def drawVtkSymb(symbType, renderer, RGBcolor, vPos, vDir, scale): '''Adds to the renderer a symbol of type 'arrow', 'doubleArrow', 'cone', 'doubleCone', 'sphere', 'doubleSphere','cube' , 'doubleCube', 'cylinder', 'doubleCylinder' :param symbType: type of symbol (available types: 'arrow', 'doubleArrow', 'cone', 'doubleCone', 'sphere', 'doubleSphere','cube' , 'doubleCube', 'cylinder', 'doubleCylinder') :param renderer: vtk renderer :param RGBcolor: list [R,G,B] with the 3 components of color :param vPos: list [x,y,z] with the 3 coordinates of the point where to place the symbol. :param vDir: director vector to orient the symbol :param scale: scale to be applied to the symbol representation ''' symTpLow = symbType.lower() if 'arrow' in symTpLow: symbSource = vtk.vtkArrowSource() elif 'cone' in symTpLow: symbSource = vtk.vtkConeSource() elif 'sphere' in symTpLow: symbSource = vtk.vtkSphereSource() elif 'cube' in symTpLow: symbSource = vtk.vtkCubeSource() elif 'cylinder' in symTpLow: symbSource = vtk.vtkCylinderSource() vPosVx = [vPos[i] - scale / 2.0 * vDir[i] for i in range(3)] #vertex position addSymb(symbSource, renderer, RGBcolor, vPosVx, vDir, scale) if 'double' in symTpLow: vPosVx = [vPosVx[i] - scale * vDir[i] for i in range(3)] #vertex position addSymb(symbSource, renderer, RGBcolor, vPosVx, vDir, scale)
def CreateArrow(self, angle=90, scale=(5, 5, 5), position=(100, 100, 100), color=(255 / 255, 0 / 255, 0 / 255)): pointer = vtk.vtkArrowSource() pointer.SetTipLength(0.15) pointer.SetTipRadius(0.08) pointer.SetTipResolution(100) pointer.SetShaftRadius(0.015) pointer.SetShaftResolution(100) transform = vtk.vtkTransform() transform.RotateWXYZ(angle, 0, 0, 1) transformFilter = vtk.vtkTransformPolyDataFilter() transformFilter.SetTransform(transform) transformFilter.SetInputConnection(pointer.GetOutputPort()) transformFilter.Update() pointerActor = vtk.vtkActor() pointerActor.SetScale(scale) pointerActor.AddPosition(position) pointerActor.GetProperty().SetColor(color) pointerMapper = vtk.vtkPolyDataMapper() pointerMapper.SetInputConnection(transformFilter.GetOutputPort()) pointerActor.SetMapper(pointerMapper) return pointerActor
def __init__(self,data_reader): self.lut=vtk.vtkLookupTable() self.lut.SetNumberOfColors(256) self.lut.SetTableRange(data_reader.get_scalar_range()) self.lut.SetHueRange(0,1) self.lut.SetRange(data_reader.get_scalar_range()) self.lut.SetRange(data_reader.get_scalar_range()) self.lut.Build() self.arrow=vtk.vtkArrowSource() self.arrow.SetTipResolution(6) self.arrow.SetTipRadius(0.1) self.arrow.SetTipLength(0.35) self.arrow.SetShaftResolution(6) self.arrow.SetShaftRadius(0.03) self.glyph=vtk.vtkGlyph3D() self.glyph.SetInput(data_reader.get_data_set()) self.glyph.SetSource(self.arrow.GetOutput()) self.glyph.SetVectorModeToUseVector() self.glyph.SetColorModeToColorByScalar() self.glyph.SetScaleModeToScaleByVector() self.glyph.OrientOn() self.glyph.SetScaleFactor(0.002) mapper=vtk.vtkPolyDataMapper() mapper.SetInput(self.glyph.GetOutput()) mapper.SetLookupTable(self.lut) mapper.ScalarVisibilityOn() mapper.SetScalarRange(data_reader.get_scalar_range()) self.actor=vtk.vtkActor() self.actor.SetMapper(mapper)
def __init__(self, scale=0.01, **kwargs): kwargs["scale"] = scale self.poly_data = vtk.vtkPolyData() self.arrow_source = vtk.vtkArrowSource() self.transform = vtk.vtkTransform() self.transform_poly_data_filter = vtk.vtkTransformPolyDataFilter() self.transform_poly_data_filter.SetTransform(self.transform) self.transform_poly_data_filter.SetInputConnection( self.arrow_source.GetOutputPort()) self.glyph = vtk.vtkGlyph3D() self.glyph.OrientOn() self.glyph.SetVectorModeToUseNormal() self.glyph.SetInput(self.poly_data) self.glyph.SetSourceConnection( self.transform_poly_data_filter.GetOutputPort()) self.mapper = vtk.vtkPolyDataMapper() self.mapper.SetInputConnection(self.glyph.GetOutputPort()) self.actor = vtk.vtkActor() self.actor.SetMapper(self.mapper) self._process_kwargs(**kwargs)
def __init__(self, node, radius, base_length, xyz=1, u_def=[]): super().__init__() self.node = node self.radius = radius self.base_length = base_length self.xyz = xyz if u_def == []: self.x = node.x self.y = node.y self.z = node.z else: self.x = u_def[0] self.y = u_def[1] self.z = u_def[2] self.arrowSource = vtk.vtkArrowSource() self.arrowSource.SetTipLength(0.2) self.arrowSource.SetShaftRadius(0.015) self.arrowSource.InvertOn() self.shiftValue = 0 self.normalizedColor = [1,1,0] self._mapper = vtk.vtkPolyDataMapper()
def drawVtkSymb(symbType,renderer, RGBcolor, vPos, vDir, scale): '''Adds to the renderer a symbol of type 'arrow', 'doubleArrow', 'cone', 'doubleCone', 'sphere', 'doubleSphere','cube' , 'doubleCube', 'cylinder', 'doubleCylinder' :param symbType: type of symbol (available types: 'arrow', 'doubleArrow', 'cone', 'doubleCone', 'sphere', 'doubleSphere','cube' , 'doubleCube', 'cylinder', 'doubleCylinder') :param renderer: vtk renderer :param RGBcolor: list [R,G,B] with the 3 components of color :param vPos: list [x,y,z] with the 3 coordinates of the point where to place the symbol. :param vDir: director vector to orient the symbol :param scale: scale to be applied to the symbol representation ''' symTpLow=symbType.lower() if 'arrow' in symTpLow: symbSource=vtk.vtkArrowSource() elif 'cone' in symTpLow: symbSource=vtk.vtkConeSource() elif 'sphere' in symTpLow: symbSource=vtk.vtkSphereSource() elif 'cube' in symTpLow: symbSource=vtk.vtkCubeSource() elif 'cylinder' in symTpLow: symbSource=vtk.vtkCylinderSource() vPosVx=[vPos[i]-scale/2.0*vDir[i] for i in range(3)] #vertex position addSymb(symbSource,renderer, RGBcolor, vPosVx, vDir, scale) if 'double' in symTpLow: vPosVx=[vPosVx[i]-scale*vDir[i] for i in range(3)] #vertex position addSymb(symbSource,renderer, RGBcolor, vPosVx, vDir, scale)
def CreateArrowsActor(pdata): """ Creates an actor composed of arrows """ # Create arrow object arrow = vtk.vtkArrowSource() arrow.Update() glyph3D = vtk.vtkGlyph3D() if new_vtk: glyph3D.SetSourceData(arrow.GetOutput()) glyph3D.SetInputData(pdata) else: glyph3D.SetSource(arrow.GetOutput()) glyph3D.SetInput(pdata) glyph3D.SetVectorModeToUseVector() glyph3D.Update() # Create mapper mapper = vtk.vtkDataSetMapper() mapper.SetInputConnection(glyph3D.GetOutputPort()) # Create actor actor = vtk.vtkActor() actor.SetMapper(mapper) actor.GetProperty().LightingOff() return actor
def __init__(self, module_manager): SimpleVTKClassModuleBase.__init__( self, module_manager, vtk.vtkArrowSource(), 'Processing.', (), ('vtkPolyData',), replaceDoc=True, inputFunctions=None, outputFunctions=None)
def __init__(self, positions: np.ndarray, vectors: np.ndarray): self.num_vectors = 0 # VTK position representation self._positions = vtk.vtkPoints() # VTK vector representation self._vectors = vtk.vtkFloatArray() self._vectors.SetName("Vector Field") self._vectors.SetNumberOfComponents(3) # Visualization Pipeline # - Data source position_data = vtk.vtkPolyData() position_data.SetPoints(self._positions) position_data.GetPointData().AddArray(self._vectors) position_data.GetPointData().SetActiveVectors("Vector Field") # - Add the vector arrays as 3D Glyphs arrow_source = vtk.vtkArrowSource() add_arrows = vtk.vtkGlyph3D() add_arrows.SetInputData(position_data) add_arrows.SetSourceConnection(arrow_source.GetOutputPort()) add_arrows.Update() # - Map the data representation to graphics primitives mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(add_arrows.GetOutputPort()) super().__init__(mapper) self.add_vectors(positions, vectors)
def __init__(self, scale=0.01, **kwargs): kwargs["scale"] = scale self.poly_data = vtk.vtkPolyData() self.arrow_source = vtk.vtkArrowSource() self.transform = vtk.vtkTransform() self.transform_poly_data_filter = vtk.vtkTransformPolyDataFilter() self.transform_poly_data_filter.SetTransform(self.transform) self.transform_poly_data_filter.SetInputConnection(self.arrow_source.GetOutputPort()) self.glyph = vtk.vtkGlyph3D() self.glyph.OrientOn() self.glyph.SetVectorModeToUseNormal() self.glyph.SetInput(self.poly_data) self.glyph.SetSourceConnection(self.transform_poly_data_filter.GetOutputPort()) self.mapper = vtk.vtkPolyDataMapper() self.mapper.SetInputConnection(self.glyph.GetOutputPort()) self.actor = vtk.vtkActor() self.actor.SetMapper(self.mapper) self._process_kwargs(**kwargs)
def arrows(self): """ Returns a glyph representation of the active vector data as arrows. Arrows will be located at the points of the mesh and their size will be dependent on the length of the vector. Their direction will be the "direction" of the vector Returns ------- arrows : pyvista.PolyData Active scalars represented as arrows. """ if self.active_vectors is None: return arrow = vtk.vtkArrowSource() arrow.Update() alg = vtk.vtkGlyph3D() alg.SetSourceData(arrow.GetOutput()) alg.SetOrient(True) alg.SetInputData(self) alg.SetVectorModeToUseVector() alg.SetScaleModeToScaleByVector() alg.Update() return pyvista.wrap(alg.GetOutput())
def __init__(self, type='default'): self.ren_widget = QWidget() self.vtk_ren_window = QVTKRenderWindowInteractor(self.ren_widget) self.vtk_renderer = vtk.vtkRenderer() self.vtk_ren_window.GetRenderWindow().AddRenderer(self.vtk_renderer) self.vtk_interactor = self.vtk_ren_window.GetRenderWindow().GetInteractor() # Create source source_dict = { "cylinder": vtk.vtkCylinderSource(), "sphere": vtk.vtkSphereSource(), "arrow": vtk.vtkArrowSource(), "cube": vtk.vtkCubeSource(), "default": vtk.vtkConeSource() } source = source_dict.get(type) # Create a mapper mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(source.GetOutputPort()) # Create an actor actor = vtk.vtkActor() actor.SetMapper(mapper) self.vtk_renderer.AddActor(actor) self.vtk_renderer.ResetCamera()
def get_actor_from_arrow_vector(start_point, end_point, color=(0, 0, 0), line_width=20): arrow_source = vtk.vtkArrowSource() random.seed(8775070) # Compute a basis normalized_x = [0] * 3 normalized_y = [0] * 3 normalized_z = [0] * 3 # The X axis is a vector from start to end math = vtk.vtkMath() math.Subtract(end_point, start_point, normalized_x) length = math.Norm(normalized_x) math.Normalize(normalized_x) # The Z axis is an arbitrary vector cross X arbitrary = [0] * 3 arbitrary[0] = random.uniform(-10, 10) arbitrary[1] = random.uniform(-10, 10) arbitrary[2] = random.uniform(-10, 10) math.Cross(normalized_x, arbitrary, normalized_z) math.Normalize(normalized_z) # The Y axis is Z cross X math.Cross(normalized_z, normalized_x, normalized_y) matrix = vtk.vtkMatrix4x4() # Create the direction cosine matrix matrix.Identity() for i in range(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, line_width, line_width) # Transform the polydata transform_pd = vtk.vtkTransformPolyDataFilter() transform_pd.SetTransform(transform) transform_pd.SetInputConnection(arrow_source.GetOutputPort()) # Create a mapper and actor for the arrow mapper = vtk.vtkPolyDataMapper() actor = vtk.vtkActor() mapper.SetInputConnection(transform_pd.GetOutputPort()) actor.SetMapper(mapper) actor.GetProperty().SetColor(color[0], color[1], color[2]) return actor
def show_velocity(self): time = self.mesh.velocity_data[self.time_step][0] mesh_velocity = self.mesh.velocity_data[self.time_step][1] surface = self.mesh.surface print("Show velocity at time step {0:d} time {1:s}".format( self.time_step, time)) num_data = mesh_velocity.GetNumberOfTuples() #print(" Number of vectors: {0:d}".format(num_data)) num_points = surface.GetNumberOfPoints() surf_points = surface.GetPoints() ## Copy velocity (not sure why I need to do this). velocity = vtk.vtkDoubleArray() velocity.SetName("velocity") velocity.SetNumberOfComponents(3) velocity.SetNumberOfTuples(num_points) for i in range(num_points): vel = mesh_velocity.GetTuple(i) velocity.SetTuple(i, vel) magnitude = vtk.vtkDoubleArray() magnitude.SetNumberOfValues(num_points) magnitude.SetName("magnitude") for i in range(num_points): vel = velocity.GetTuple(i) mag = sqrt(vel[0] * vel[0] + vel[1] * vel[1] + vel[2] * vel[2]) magnitude.SetValue(i, mag) arrow_mesh = vtk.vtkPolyData() arrow_mesh.DeepCopy(surface) arrow_mesh.GetPointData().AddArray(velocity) arrow_mesh.GetPointData().SetActiveVectors("velocity") arrow_mesh.GetPointData().AddArray(magnitude) arrow_mesh.GetPointData().SetActiveScalars("magnitude") ## Create arrows. # arrow_source = vtk.vtkArrowSource() arrow_source.Update() #arrow_source.SetShaftRadius(1.0) #arrow_source.SetTipLength(.9) glyph = vtk.vtkGlyph3D() glyph.SetInputData(arrow_mesh) glyph.SetSourceConnection(arrow_source.GetOutputPort()) glyph.SetScaleFactor(self.velocity_scale) #glyph.SetScaleModeToScaleByScalar() #glyph.OrientOn() glyph.SetVectorModeToUseVector() glyph.SetColorModeToColorByScalar() glyph.Update() mapper = vtk.vtkPolyDataMapper() mapper.SetInputData(glyph.GetOutput()) actor = vtk.vtkActor() self.arrow_actor = actor actor.SetMapper(mapper) self.renderer.AddActor(actor) self.window.Render()
def __init__(self, startPoint, endPoint, zAxis, clr2plt): super().__init__() colors = vtk.vtkNamedColors() USER_MATRIX = False # Create an arrow. arrowSource = vtk.vtkArrowSource() # Compute a basis normalizedX = [0 for i in range(3)] normalizedY = [0 for i in range(3)] normalizedZ = [0 for i in range(3)] # The X axis is a vector from start to end math = vtk.vtkMath() math.Subtract(endPoint, startPoint, normalizedX) length = math.Norm(normalizedX) print(length) math.Normalize(normalizedX) # The Z axis is an arbitrary vector cross X arbitrary = zAxis math.Cross(normalizedX, arbitrary, normalizedZ) math.Normalize(normalizedZ) # The Y axis is Z cross X math.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() if USER_MATRIX: mapper.SetInputConnection(arrowSource.GetOutputPort()) self.SetUserMatrix(transform.GetMatrix()) else: mapper.SetInputConnection(transformPD.GetOutputPort()) self.SetMapper(mapper) self.GetProperty().SetColor(colors.GetColor3d(clr2plt)) renderer.AddActor(self)
def __init__(self, module_manager): SimpleVTKClassModuleBase.__init__(self, module_manager, vtk.vtkArrowSource(), 'Processing.', (), ('vtkPolyData', ), replaceDoc=True, inputFunctions=None, outputFunctions=None)
def makeArrow(self): '''Make arrow with current parameter settings ''' arrow = vtk.vtkArrowSource() arrow.SetShaftRadius(self._shaftRadius) arrow.SetTipLength(self._tipLength) return arrow
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 wind_actor(x, y, speed, deg): arrow_length = speed * 10 arrow_source = vtk.vtkArrowSource() arrow_source.SetShaftResolution(50) arrow_source.SetTipResolution(50) start_point = [x, y, 25] end_point = [x - arrow_length * sin(radians(deg)), y - arrow_length * cos(radians(deg)), 25] normalizedX = [0 for i in range(3)] normalizedY = [0 for i in range(3)] normalizedZ = [0 for i in range(3)] # The X axis is a vector from start to end math = vtk.vtkMath() math.Subtract(end_point, start_point, normalizedX) length = math.Norm(normalizedX) math.Normalize(normalizedX) # The Z axis is an arbitrary vector cross X arbitrary = [0 for i in range(3)] arbitrary[0] = 1 arbitrary[1] = 1 arbitrary[2] = 1 math.Cross(normalizedX, arbitrary, normalizedZ) math.Normalize(normalizedZ) # The Y axis is Z cross X math.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]) transform = vtk.vtkTransform() transform.Translate(start_point) transform.Concatenate(matrix) transform.Scale(length, length, length) transform_filter = vtk.vtkTransformPolyDataFilter() transform_filter.SetTransform(transform) transform_filter.SetInputConnection(arrow_source.GetOutputPort()) mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(transform_filter.GetOutputPort()) actor = vtk.vtkActor() actor.SetMapper(mapper) actor.GetProperty().SetColor(255, 0, 0) actor.SetVisibility(True) return actor
def __init__(self): super(Arrow, self).__init__() self.arrow = vtk.vtkArrowSource() self.prim = vtk.vtkTransformPolyDataFilter() self.end_point = [0, 0, 0] self.start_point = [1, 0, 0] self.shaft_radius = 0.03 self.tip_radius = 0.1 self.length_ratio = 0.35
def __init__(self): self.source = vtk.vtkArrowSource() self.mapper = vtk.vtkPolyDataMapper() self.mapper.SetInputConnection(self.source.GetOutputPort()) self.mapper.Update() self.actor = vtk.vtkActor() self.actor.SetMapper(self.mapper)
def Arrow(start=(0.,0.,0.), direction=(1.,0.,0.), tip_length=0.25, tip_radius=0.1, tip_resolution=20, shaft_radius=0.05, shaft_resolution=20, scale=None): """Create a vtk Arrow. Parameters ---------- start : np.ndarray Start location in [x, y, z] direction : list or np.ndarray Direction the arrow points to in [x, y, z] tip_length : float, optional Length of the tip. tip_radius : float, optional Radius of the tip. tip_resolution : int, optional Number of faces around the tip. shaft_radius : float, optional Radius of the shaft. shaft_resolution : int, optional Number of faces around the shaft. scale : float or str, optional Scale factor of the entire object, default is None (i.e. scale of 1). 'auto' scales to length of direction array. Return ------ arrow : pyvista.PolyData Arrow surface. """ # Create arrow object arrow = vtk.vtkArrowSource() arrow.SetTipLength(tip_length) arrow.SetTipRadius(tip_radius) arrow.SetTipResolution(tip_resolution) arrow.SetShaftRadius(shaft_radius) arrow.SetShaftResolution(shaft_resolution) arrow.Update() surf = pyvista.PolyData(arrow.GetOutput()) if scale == 'auto': scale = float(np.linalg.norm(direction)) if isinstance(scale, float) or isinstance(scale, int): surf.points *= scale elif scale is not None: raise TypeError("Scale must be either float, int or 'auto'.") translate(surf, start, direction) return surf
def create_arrow(): """ Create arrow: specify here all the parameters :return: arrow """ arrow = vtk.vtkArrowSource() arrow.Update() return arrow
def Arrows(startPoints, endPoints=None, s=None, scale=1, c="r", alpha=1, res=12): """ Build arrows between two lists of points `startPoints` and `endPoints`. `startPoints` can be also passed in the form ``[[point1, point2], ...]``. A dolfin ``Mesh`` that was deformed/modified by a function can be passed together as inputs. :param float s: cross-section size of the arrow :param float scale: apply a rescaling factor to the length """ if endPoints is not None: startPoints = list(zip(startPoints, endPoints)) polyapp = vtk.vtkAppendPolyData() for twopts in startPoints: startPoint, endPoint = twopts axis = np.array(endPoint) - np.array(startPoint) length = np.linalg.norm(axis) if length: axis /= length theta = np.arccos(axis[2]) phi = np.arctan2(axis[1], axis[0]) arr = vtk.vtkArrowSource() arr.SetShaftResolution(res) arr.SetTipResolution(res) if s: sz = 0.02 arr.SetTipRadius(sz) arr.SetShaftRadius(sz / 1.75) arr.SetTipLength(sz * 15) t = vtk.vtkTransform() t.Translate(startPoint) t.RotateZ(phi * 57.3) t.RotateY(theta * 57.3) t.RotateY(-90) # put it along Z if s: sz = 800.0 * s t.Scale(length * scale, sz * scale, sz * scale) else: t.Scale(length * scale, length * scale, length * scale) tf = vtk.vtkTransformPolyDataFilter() tf.SetInputConnection(arr.GetOutputPort()) tf.SetTransform(t) polyapp.AddInputConnection(tf.GetOutputPort()) polyapp.Update() actor = Actor(polyapp.GetOutput(), c, alpha) settings.collectable_actors.append(actor) return actor
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 create_arrow(self): source = vtk.vtkArrowSource() # Create a mapper and actor mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(source.GetOutputPort()) actor = vtk.vtkActor() actor.SetMapper(mapper) self.render.AddActor(actor)
def __init__(self, module_manager): ModuleBase.__init__(self, module_manager) InputArrayChoiceMixin.__init__(self) self._config.scaling = True self._config.scaleFactor = 1 self._config.scaleMode = glyphScaleMode.index('SCALE_BY_VECTOR') self._config.colourMode = glyphColourMode.index('COLOUR_BY_VECTOR') self._config.vectorMode = glyphVectorMode.index('USE_VECTOR') self._config.mask_on_ratio = 5 self._config.mask_random = True configList = [ ('Scale glyphs:', 'scaling', 'base:bool', 'checkbox', 'Should the size of the glyphs be scaled?'), ('Scale factor:', 'scaleFactor', 'base:float', 'text', 'By how much should the glyph size be scaled if scaling is ' 'active?'), ('Scale mode:', 'scaleMode', 'base:int', 'choice', 'Should scaling be performed by vector, scalar or only factor?', glyphScaleModeTexts), ('Colour mode:', 'colourMode', 'base:int', 'choice', 'Colour is determined based on scalar or vector magnitude.', glyphColourModeTexts), ('Vector mode:', 'vectorMode', 'base:int', 'choice', 'Should vectors or normals be used for scaling and orientation?', glyphVectorModeTexts), ('Vectors selection:', 'vectorsSelection', 'base:str', 'choice', 'The attribute that will be used as vectors for the warping.', (input_array_choice_mixin.DEFAULT_SELECTION_STRING,)), ('Mask on ratio:', 'mask_on_ratio', 'base:int', 'text', 'Every Nth point will be glyphed.'), ('Random masking:', 'mask_random', 'base:bool', 'checkbox', 'Pick random distribution of Nth points.')] self._mask_points = vtk.vtkMaskPoints() module_utils.setup_vtk_object_progress(self, self._mask_points, 'Masking points.') self._glyphFilter = vtk.vtkGlyph3D() asrc = vtk.vtkArrowSource() self._glyphFilter.SetSource(0, asrc.GetOutput()) self._glyphFilter.SetInput(self._mask_points.GetOutput()) module_utils.setup_vtk_object_progress(self, self._glyphFilter, 'Creating glyphs.') ScriptedConfigModuleMixin.__init__( self, configList, {'Module (self)' : self, 'vtkGlyph3D' : self._glyphFilter}) self.sync_module_logic_with_config()
def render(self, pointsData, scalarsArray, vectorsArray, nspecies, colouringOptions, vectorsOptions, lut, invert=False): """ Render vectors. """ self._logger.debug("Rendering vectors") # points points = vtk.vtkPoints() points.SetData(pointsData.getVTK()) # polydata arrowPolyData = vtk.vtkPolyData() arrowPolyData.SetPoints(points) arrowPolyData.GetPointData().SetScalars(scalarsArray.getVTK()) arrowPolyData.GetPointData().SetVectors(vectorsArray.getVTK()) # arrow source arrowSource = vtk.vtkArrowSource() arrowSource.SetShaftResolution(vectorsOptions.vectorResolution) arrowSource.SetTipResolution(vectorsOptions.vectorResolution) if invert: arrowSource.InvertOn() arrowSource.Update() # glyph mapper arrowGlyph = vtk.vtkGlyph3DMapper() arrowGlyph.OrientOn() if vtk.vtkVersion.GetVTKMajorVersion() <= 5: arrowGlyph.SetInputConnection(arrowPolyData.GetProducerPort()) else: arrowGlyph.SetInputData(arrowPolyData) arrowGlyph.SetSourceConnection(arrowSource.GetOutputPort()) arrowGlyph.SetScaleModeToScaleByMagnitude() arrowGlyph.SetScaleArray("vectors") arrowGlyph.SetScalarModeToUsePointFieldData() arrowGlyph.SelectColorArray("colours") arrowGlyph.SetScaleFactor(vectorsOptions.vectorScaleFactor) arrowMapper = arrowGlyph arrowMapper.SetLookupTable(lut) utils.setMapperScalarRange(arrowMapper, colouringOptions, nspecies) # actor arrowActor = vtk.vtkActor() arrowActor.SetMapper(arrowMapper) # store attributes self._actor = utils.ActorObject(arrowActor) self._data["Points"] = pointsData self._data["Scalars"] = scalarsArray self._data["Vectors"] = vectorsArray self._data["LUT"] = lut self._data["Scale factor"] = vectorsOptions.vectorScaleFactor
def draw(self, graphics): cell, pointnums = super(Arrow, self).draw(graphics) assert len(pointnums) == 2 arrow = vtk.vtkArrowSource() p1, p2 = graphics.get_points(*pointnums) transform = vtk.vtkTransform() transform.Translate(p1) length = norm(p2-p1) transform.Scale(length, length, length) pass
def addarrow(pos=(0,0,0),color=(1,0,0),opacity=1): arrow = vtk.vtkArrowSource() arrowm = vtk.vtkPolyDataMapper() arrowm.SetInput(arrow.GetOutput()) arrowa= vtk.vtkActor() arrowa.SetMapper(arrowm) arrowa.GetProperty().SetColor(color) arrowa.GetProperty().SetOpacity(opacity) return arrowa
def renderthis(self): # open a window and create a renderer self.ren = vtk.vtkRenderer() self.widget.GetRenderWindow().AddRenderer(self.ren) # to generate polygonal data for a arrow. Arrow = vtk.vtkArrowSource() Arrow.SetShaftResolution(100) Arrow.SetTipResolution(100) #invert arrow so the point which is referenced is the top of the point Arrow.InvertOn() # take the polygonal data from the vtkArrowSource and assign to variable arrowmapper ArrowMapper = vtk.vtkPolyDataMapper() ArrowMapper.SetInputConnection(Arrow.GetOutputPort()) # create an actor for our scene (arrowactor) self.ArrowActor = vtk.vtkActor() self.ArrowActor.SetMapper(ArrowMapper) self.ArrowActor.GetProperty().SetColor(1,1,0) self.ArrowActor.GetProperty().SetOpacity(0.60) self.ArrowActor.GetProperty().EdgeVisibilityOn() self.ArrowActor.GetProperty().SetColor(0.1,0.1,0.1) # set tip position to (0,0,0) self.position=(0,0,0) self.ArrowActor.SetPosition(self.position) # get and print arrow position self.ArrowPos = self.ArrowActor.GetPosition() #print self.ArrowPos # Add actor to renderer window #self.ren.AddActor(self.ArrowActor) # Background colour lightgrey self.ren.SetBackground(0.9,0.9,0.9) #create a X,Y,Z axes to show 3d position: # create axes variable and load vtk axes actor self.axes = vtk.vtkAxesActor() self.marker = vtk.vtkOrientationMarkerWidget() # set the interactor. self.widget._Iren is inbuilt python mechanism for current renderer window. self.marker.SetInteractor(self.widget._Iren ) self.marker.SetOrientationMarker(self.axes ) # set size and position of window (Xmin,Ymin,Xmax,Ymax) self.marker.SetViewport(0.75,0,1,0.25) #Allow user input self.marker.SetEnabled(1) # #settings for renderer window self.ren.ResetCamera() self.ren.ResetCameraClippingRange() self.isplotted = True self.p=0
def attach_vel(self): vel = self._vel * 1e-2 rad = self._rad if vel is not None and rad is not None: velMag = norm(vel, axis=1) velMag_vtk = numpy_support.numpy_to_vtk(num_array=velMag.ravel(), deep=True, array_type=vtk.VTK_FLOAT) velMag_vtk.SetName("veloMag") vecVel = vtk.vtkFloatArray() vecVel.SetNumberOfComponents(3) for i, v in enumerate(vel): vecVel.InsertTuple3(i, v[0], v[1], v[2]) #Put an arrow (vector) at each ball arrow = vtk.vtkArrowSource() arrow.SetTipRadius(rad.mean() * 10) arrow.SetShaftRadius(rad.mean() * 10) poly = vtk.vtkPolyData() poly.SetPoints(self._points) poly.GetPointData().AddArray(velMag_vtk) poly.GetPointData().SetActiveScalars("veloMag") arrowGlyph = vtk.vtkGlyph3D() arrowGlyph.SetInputData(poly) arrowGlyph.SetSourceConnection(arrow.GetOutputPort()) arrowGlyph.SetVectorModeToUseVector() poly.GetPointData().SetVectors(vecVel) # If we do not want the Arrow's size to depend on the Scalar # then arrowGlyph.SetScaleModeToDataScalingOff() must be called arrowMapper = vtk.vtkPolyDataMapper() arrowMapper.SetInputConnection(arrowGlyph.GetOutputPort()) self._addScalarBar(velMag) arrowMapper.SetLookupTable(self._colorTransferFunction) arrowActor = vtk.vtkActor() arrowActor.SetMapper(arrowMapper) arrowActor.GetProperty().SetColor(1,1,0) self._ren.AddActor(arrowActor) else: print("No particles found. Make sure the particles loaded have velocities and radii.")
def __init__(self, maxnorm, scale=1): vtkClampedGlyphSource.__init__(self, scale, vtkArrowSource(), range_min=0.0, range_max=maxnorm) self.vtk_property.SetColor(1.0, 0.25, 0.25) # forces are red self.vtk_property.SetInterpolationToPhong() self.vtk_property.SetDiffuse(0.7) self.vtk_property.SetSpecular(0.4) self.vtk_property.SetSpecularPower(20) self.vtk_glyph_source.SetShaftResolution(12) self.vtk_glyph_source.SetShaftRadius(0.03*avg_radius) #default 0.03 self.vtk_glyph_source.SetTipResolution(20) self.vtk_glyph_source.SetTipLength(0.3*avg_radius) #default 0.35 self.vtk_glyph_source.SetTipRadius(0.1*avg_radius) #default 0.1
def draw_arrow(startPoint,length,direction,renderer,invert,color): """ Draws and scales an arrow with a defined starting point, direction and length, adds to the renderer, returns the actor. """ arrowSource=vtk.vtkArrowSource() arrowSource.SetShaftRadius(0.024) arrowSource.SetTipRadius(0.07) arrowSource.SetTipLength(0.14) if invert: arrowSource.InvertOn() else: arrowSource.InvertOff() endPoint=startPoint+length*direction normalizedX=(endPoint-startPoint)/length arbitrary=np.array([1,1,1]) #can be replaced with a random vector normalizedZ=np.cross(normalizedX,arbitrary/np.linalg.norm(arbitrary)) normalizedY=np.cross(normalizedZ,normalizedX) # Create the direction cosine matrix by writing values directly to an identity matrix matrix = vtk.vtkMatrix4x4() 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 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 mapper and actor mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(transformPD.GetOutputPort()) actor = vtk.vtkActor() actor.SetMapper(mapper) actor.GetProperty().SetColor(color) renderer.AddActor(actor) return actor
def _arrow(pos=(0,0,0),color=(1,0,0),scale=(1,1,1),opacity=1): ''' Internal function for generating arrow actors. ''' arrow = vtk.vtkArrowSource() #arrow.SetTipLength(length) arrowm = vtk.vtkPolyDataMapper() arrowm.SetInput(arrow.GetOutput()) arrowa= vtk.vtkActor() arrowa.SetMapper(arrowm) arrowa.GetProperty().SetColor(color) arrowa.GetProperty().SetOpacity(opacity) arrowa.SetScale(scale) return arrowa
def MakeGlyphs(src, reverseNormals): ''' Glyph the normals on the surface. You may need to adjust the parameters for maskPts, arrow and glyph for a nice appearance. :param: src - the surface to glyph. :param: reverseNormals - if True the normals on the surface are reversed. :return: The glyph object. ''' # Sometimes the contouring algorithm can create a volume whose gradient # vector and ordering of polygon (using the right hand rule) are # inconsistent. vtkReverseSense cures this problem. reverse = vtk.vtkReverseSense() # Choose a random subset of points. maskPts = vtk.vtkMaskPoints() maskPts.SetOnRatio(5) maskPts.RandomModeOn() if reverseNormals: reverse.SetInputData(src) reverse.ReverseCellsOn() reverse.ReverseNormalsOn() maskPts.SetInputConnection(reverse.GetOutputPort()) else: maskPts.SetInputData(src) # Source for the glyph filter arrow = vtk.vtkArrowSource() arrow.SetTipResolution(16) arrow.SetTipLength(0.3) arrow.SetTipRadius(0.1) glyph = vtk.vtkGlyph3D() glyph.SetSourceConnection(arrow.GetOutputPort()) glyph.SetInputConnection(maskPts.GetOutputPort()) glyph.SetVectorModeToUseNormal() glyph.SetScaleFactor(1) glyph.SetColorModeToColorByVector() glyph.SetScaleModeToScaleByVector() glyph.OrientOn() glyph.Update() return glyph
def update(self): # Source for the glyph filter arrow = vtkArrowSource() arrow.SetTipResolution(8) arrow.SetTipLength(0.3) arrow.SetTipRadius(0.1) glyph = vtkGlyph3D() glyph.SetSourceConnection(arrow.GetOutputPort()) glyph.SetInput(self.input_) glyph.SetVectorModeToUseNormal() glyph.SetScaleFactor(0.1) #glyph.SetColorModeToColorByVector() #glyph.SetScaleModeToScaleByVector() glyph.OrientOn() glyph.Update() self.output_ = glyph.GetOutput()
def __init__(self, center=(0, 0, 0), color=(0, 0, 1), rotXYZ=(0, 0, 0)): """ arrow """ self.src = vtk.vtkArrowSource() # self.src.SetCenter(center) transform = vtk.vtkTransform() transform.Translate(center[0], center[1], center[2]) transform.RotateX(rotXYZ[0]) transform.RotateY(rotXYZ[1]) transform.RotateZ(rotXYZ[2]) transformFilter = vtk.vtkTransformPolyDataFilter() transformFilter.SetTransform(transform) transformFilter.SetInputConnection(self.src.GetOutputPort()) transformFilter.Update() self.mapper = vtk.vtkPolyDataMapper() self.mapper.SetInputConnection(transformFilter.GetOutputPort()) self.SetMapper(self.mapper) self.SetColor(color)
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() input_ = vtk.vtkPolyData() input_.ShallowCopy(sphereSource.GetOutput()) arrowSource = vtk.vtkArrowSource() glyph3D = vtk.vtkGlyph3D() glyph3D.SetSourceConnection(arrowSource.GetOutputPort()) glyph3D.SetVectorModeToUseNormal() glyph3D.SetInput(input_) glyph3D.SetScaleFactor(0.2) glyph3D.Update() # Create a mapper mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(glyph3D.GetOutputPort()) # Create an actor actor = vtk.vtkActor() actor.SetMapper(mapper) self.ren.AddActor(actor) self.ren.ResetCamera() self._initialized = False
def ex2(): arrowSource = vtk.vtkArrowSource() # arrowSource.SetShaftRadius(0.01) # arrowSource.SetTipLength(.9) # Create a mapper and actor mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(arrowSource.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(.1, .2, .3) # Background color dark blue renderWindow.Render() renderWindowInteractor.Start()
def set_glyph_mode (self, event=None): debug ("In Glyph::set_glyph_mode ()") Common.state.busy () val = self.glyph_var.get () if val == 0: # 2d glyph self.glyph_src = vtk.vtkGlyphSource2D () self.glyph_src.SetGlyphTypeToArrow () elif val == 1: # Cone self.glyph_src = vtk.vtkConeSource() elif val == 2: # Sphere self.glyph_src = vtk.vtkSphereSource() self.glyph_src.SetPhiResolution(4) self.glyph_src.SetThetaResolution(4) elif val == 3: # Cube self.glyph_src = vtk.vtkCubeSource() elif val == 4: # Cylinder self.glyph_src = vtk.vtkCylinderSource() elif val == 5: # 3D arrow self.glyph_src = vtk.vtkArrowSource() self.glyph.SetSource (self.glyph_src.GetOutput ()) self.renwin.Render () Common.state.idle ()
def __init__(self, parent, data_dir): super(QGlyphViewer,self).__init__(parent) # Make tha actual QtWidget a child so that it can be re parented interactor = QVTKRenderWindowInteractor(self) self.layout = QtGui.QHBoxLayout() self.layout.addWidget(interactor) self.layout.setContentsMargins(0,0,0,0) self.setLayout(self.layout) # Read the data xyx_file = os.path.join(data_dir, "combxyz.bin") q_file = os.path.join(data_dir, "combq.bin") pl3d = vtk.vtkMultiBlockPLOT3DReader() pl3d.SetXYZFileName(xyx_file) pl3d.SetQFileName(q_file) pl3d.SetScalarFunctionNumber(100) pl3d.SetVectorFunctionNumber(202) pl3d.Update() blocks = pl3d.GetOutput() b0 = blocks.GetBlock(0) # Setup VTK environment renderer = vtk.vtkRenderer() render_window = interactor.GetRenderWindow() render_window.AddRenderer(renderer) interactor.SetInteractorStyle(vtk.vtkInteractorStyleTrackballCamera()) render_window.SetInteractor(interactor) renderer.SetBackground(0.2,0.2,0.2) # Draw Outline outline = vtk.vtkStructuredGridOutlineFilter() outline.SetInputData(b0) outline_mapper = vtk.vtkPolyDataMapper() outline_mapper.SetInputConnection(outline.GetOutputPort()) outline_actor = vtk.vtkActor() outline_actor.SetMapper(outline_mapper) outline_actor.GetProperty().SetColor(1,1,1) renderer.AddActor(outline_actor) renderer.ResetCamera() # Draw Outline outline = vtk.vtkStructuredGridOutlineFilter() outline.SetInputData(b0) outline_mapper = vtk.vtkPolyDataMapper() outline_mapper.SetInputConnection(outline.GetOutputPort()) outline_actor = vtk.vtkActor() outline_actor.SetMapper(outline_mapper) outline_actor.GetProperty().SetColor(1,1,1) renderer.AddActor(outline_actor) renderer.ResetCamera() # Threshold points threshold = vtk.vtkThresholdPoints() threshold.SetInputData(b0) threshold.ThresholdByUpper(0.5) # Draw arrows arrow = vtk.vtkArrowSource() glyphs = vtk.vtkGlyph3D() glyphs.SetInputData(b0) glyphs.SetSourceConnection(arrow.GetOutputPort()) glyphs.SetInputConnection(threshold.GetOutputPort()) glyphs.SetVectorModeToUseVector() glyphs.SetScaleModeToScaleByVector() glyphs.SetScaleFactor(0.005) glyphs.SetColorModeToColorByVector() # Mapper glyph_mapper = vtk.vtkPolyDataMapper() glyph_mapper.SetInputConnection(glyphs.GetOutputPort()) glyph_actor = vtk.vtkActor() glyph_actor.SetMapper(glyph_mapper) glyph_mapper.UseLookupTableScalarRangeOn() renderer.AddActor(glyph_actor) # Set color lookuptable glyphs.Update() s0,sf = glyphs.GetOutput().GetScalarRange() lut = vtk.vtkColorTransferFunction() lut.AddRGBPoint(s0, 1,0,0) lut.AddRGBPoint(sf, 0,1,0) glyph_mapper.SetLookupTable(lut) self.b0 = b0 self.renderer = renderer self.interactor = interactor self.threshold = threshold
import vtk class my_style(vtk.vtkInteractorStyleJoystickActor): def __init__(self, parent=None): print "hhhhh" sphere1 = vtk.vtkSphereSource() sphere1.SetCenter(4, 3, 4) sphere1.SetRadius(2) sphere1.SetPhiResolution(8) arrow1 = vtk.vtkArrowSource() arrow1.SetTipLength(4) arrow1.SetShaftRadius(0.3) arrow1.SetShaftResolution(1) sphere_mapper = vtk.vtkPolyDataMapper() arrow_mapper = vtk.vtkPolyDataMapper() sphere_mapper.SetInputConnection(sphere1.GetOutputPort()) arrow_mapper.SetInputConnection(arrow1.GetOutputPort()) sphere_actor = vtk.vtkActor() arrow_actor = vtk.vtkActor() sphere_actor.SetMapper(sphere_mapper) arrow_actor.SetMapper(arrow_mapper) property1 = vtk.vtkProperty() property1.SetColor(255, 0, 255)
def buildPipeline(self): """ execute() -> None Dispatch the vtkRenderer to the actual rendering widget """ self.colorInputModule = self.wmod.forceGetInputFromPort( "colors", None ) if self.input() == None: print>>sys.stderr, "Must supply 'volume' port input to VectorCutPlane" return xMin, xMax, yMin, yMax, zMin, zMax = self.input().GetWholeExtent() spacing = self.input().GetSpacing() sx, sy, sz = spacing origin = self.input().GetOrigin() ox, oy, oz = origin cellData = self.input().GetCellData() pointData = self.input().GetPointData() vectorsArray = pointData.GetVectors() if vectorsArray == None: print>>sys.stderr, "Must supply point vector data for 'volume' port input to VectorVolume" return self.setRangeBounds( list( vectorsArray.GetRange(-1) ) ) self.nComponents = vectorsArray.GetNumberOfComponents() for iC in range(-1,3): print "Value Range %d: %s " % ( iC, str( vectorsArray.GetRange( iC ) ) ) for iV in range(10): print "Value[%d]: %s " % ( iV, str( vectorsArray.GetTuple3( iV ) ) ) self.initialOrigin = self.input().GetOrigin() self.initialExtent = self.input().GetExtent() self.initialSpacing = self.input().GetSpacing() self.dataBounds = self.getUnscaledWorldExtent( self.initialExtent, self.initialSpacing, self.initialOrigin ) dataExtents = ( (self.dataBounds[1]-self.dataBounds[0])/2.0, (self.dataBounds[3]-self.dataBounds[2])/2.0, (self.dataBounds[5]-self.dataBounds[4])/2.0 ) centroid = ( (self.dataBounds[0]+self.dataBounds[1])/2.0, (self.dataBounds[2]+self.dataBounds[3])/2.0, (self.dataBounds[4]+self.dataBounds[5])/2.0 ) self.pos = [ self.initialSpacing[i]*self.initialExtent[2*i] for i in range(3) ] if ( (self.initialOrigin[0] + self.pos[0]) < 0.0): self.pos[0] = self.pos[0] + 360.0 self.resample = vtk.vtkExtractVOI() self.resample.SetInput( self.input() ) self.resample.SetVOI( self.initialExtent ) self.ApplyGlyphDecimationFactor() lut = self.getLut() if self.colorInputModule <> None: colorInput = self.colorInputModule.getOutput() self.color_resample = vtk.vtkExtractVOI() self.color_resample.SetInput( colorInput ) self.color_resample.SetVOI( self.initialExtent ) self.color_resample.SetSampleRate( sampleRate, sampleRate, 1 ) # self.probeFilter = vtk.vtkProbeFilter() # self.probeFilter.SetSourceConnection( self.resample.GetOutputPort() ) # colorInput = self.colorInputModule.getOutput() # self.probeFilter.SetInput( colorInput ) resampledColorInput = self.color_resample.GetOutput() shiftScale = vtk.vtkImageShiftScale() shiftScale.SetOutputScalarTypeToFloat () shiftScale.SetInput( resampledColorInput ) valueRange = self.getScalarRange() shiftScale.SetShift( valueRange[0] ) shiftScale.SetScale ( (valueRange[1] - valueRange[0]) / 65535 ) colorFloatInput = shiftScale.GetOutput() colorFloatInput.Update() colorInput_pointData = colorFloatInput.GetPointData() self.colorScalars = colorInput_pointData.GetScalars() self.colorScalars.SetName('color') lut.SetTableRange( valueRange ) self.glyph = vtk.vtkGlyph3DMapper() # if self.colorInputModule <> None: self.glyph.SetColorModeToColorByScalar() # else: self.glyph.SetColorModeToColorByVector() scalarRange = self.getScalarRange() self.glyph.SetScaleModeToScaleByMagnitude() self.glyph.SetColorModeToMapScalars() self.glyph.SetUseLookupTableScalarRange(1) self.glyph.SetOrient( 1 ) # self.glyph.ClampingOn() self.glyph.SetRange( scalarRange[0:2] ) self.glyph.SetInputConnection( self.resample.GetOutputPort() ) self.arrow = vtk.vtkArrowSource() self.glyph.SetSourceConnection( self.arrow.GetOutputPort() ) self.glyph.SetLookupTable( lut ) self.glyphActor = vtk.vtkActor() self.glyphActor.SetMapper( self.glyph ) self.renderer.AddActor( self.glyphActor ) self.renderer.SetBackground( VTK_BACKGROUND_COLOR[0], VTK_BACKGROUND_COLOR[1], VTK_BACKGROUND_COLOR[2] ) self.set3DOutput(wmod=self.wmod)
reader.Update() grid = reader.GetOutput() # grab the model centre and bounds centre = grid.GetCenter() bounds = grid.GetBounds() # grab the norm of the vectors norm = vtk.vtkVectorNorm() norm.SetInput(grid) maxNorm = grid.GetPointData().GetVectors().GetMaxNorm() # to make arrow glyphs need an arrow source arrow = vtk.vtkArrowSource() # the arrows are 3D glyphs so set that up now glyph = vtk.vtkGlyph3D() glyph.ScalingOn() glyph.SetScaleModeToScaleByScalar() glyph.SetColorModeToColorByScalar() glyph.SetVectorModeToUseVector() glyph.SetScaleFactor(0.1/maxNorm) glyph.SetInput(norm.GetOutput()) glyph.SetSource(arrow.GetOutput()) glyph.ClampingOff() # set up a stripper to speed up rendering stripper = vtk.vtkStripper() stripper.SetInput(glyph.GetOutput())
lengths.SetValue(0, math.sqrt(1*1+1*1+1*1)) lengths.SetValue(1, math.sqrt(2*2+2*2+2*2)) lengths.SetValue(2, math.sqrt(3*3+3*3+3*3)) polydata.GetPointData().AddArray(lengths) colors= vtk.vtkDoubleArray() colors.SetName('Z') colors.SetNumberOfValues(3); colors.SetValue(0, 1); colors.SetValue(1, 2); colors.SetValue(2, 3); polydata.GetPointData().AddArray(colors) # Generate the arrow for the glyphs arrow = vtk.vtkArrowSource()#vtk.vtkConeSource() #arrow.SetRadius(0.1) #arrow.SetHeight(0.5) # Set up the glyph filter glyph = vtk.vtkGlyph3D() glyph.SetInput(polydata) glyph.SetSourceConnection(arrow.GetOutputPort()) glyph.ScalingOn() glyph.SetScaleModeToScaleByScalar() glyph.SetVectorModeToUseVector() glyph.OrientOn() # Tell the filter to "clamp" the scalar range #glyph.ClampingOn()
cone_glyph[mu].SetScaleFactor(cone_glyph[mu]._scale_fact * scale_factor) cone_glyph[mu].SetVectorModeToUseVector() cone_glyph[mu].SetInputArrayToProcess(1, 0, 0, 0, 'contactNormals') cone_glyph[mu].OrientOn() cmapper[mu] = vtk.vtkPolyDataMapper() cmapper[mu].SetInputConnection(cone_glyph[mu].GetOutputPort()) cactor[mu] = vtk.vtkActor() cactor[mu].GetProperty().SetOpacity(0.4) cactor[mu].GetProperty().SetColor(0, 0, 1) cactor[mu].SetMapper(cmapper[mu]) arrow[mu] = vtk.vtkArrowSource() arrow[mu].SetTipResolution(40) arrow[mu].SetShaftResolution(40) cylinder[mu] = vtk.vtkCylinderSource() cylinder[mu].SetRadius(.01) cylinder[mu].SetHeight(1) sphere[mu] = vtk.vtkSphereSource() # 1. scale = (scalar value of that particular data index); # 2. denominator = Range[1] - Range[0]; # 3. scale = (scale < Range[0] ? Range[0] : (scale > Range[1] ? Range[1] : scale)); # 4. scale = (scale - Range[0]) / denominator; # 5. scale *= scaleFactor;