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;
