def vtkVariantStrictEquality(s1, s2):
"""
Check two variants for strict equality of type and value.
"""
s1 = vtk.vtkVariant(s1)
s2 = vtk.vtkVariant(s2)
t1 = s1.GetType()
t2 = s2.GetType()
# check based on type
if t1 != t2:
return False
v1 = s1.IsValid()
v2 = s2.IsValid()
# check based on validity
if (not v1) and (not v2):
return True
elif v1 != v2:
return False
# extract and compare the values
r1 = getattr(s1, _variant_method_map[t1])()
r2 = getattr(s2, _variant_method_map[t2])()
return (r1 == r2)
def vtkVariantStrictWeakOrder(s1, s2):
"""
Compare variants by type first, and then by value. The return values
are -1, 0, 1 like the python cmp() method, for compatibility with the
python list sort() method. This is in contrast with the C++ version,
which returns true or false.
"""
s1 = vtkVariant(s1)
s2 = vtkVariant(s2)
t1 = s1.GetType()
t2 = s2.GetType()
# check based on type
if t1 != t2:
return cmp(t1, t2)
v1 = s1.IsValid()
v2 = s2.IsValid()
# check based on validity
if (not v1) and (not v2):
return 0
elif v1 != v2:
return cmp(v1, v2)
# extract and compare the values
r1 = getattr(s1, _variant_method_map[t1])()
r2 = getattr(s2, _variant_method_map[t2])()
# compare vtk objects by classname
if t1 == vtk.VTK_OBJECT:
return cmp(r1.GetClassName(), r2.GetClassName())
return cmp(r1, r2)
def main():
# Use the specified filename
output_filename = get_program_parameters()
# Construct an empty table
table = vtk.vtkTable()
for i in range(0, 3):
col = vtk.vtkVariantArray()
col_name = "column-" + str(i)
col.SetName(col_name)
col.InsertNextValue(vtk.vtkVariant(0.0))
col.InsertNextValue(vtk.vtkVariant(0.0))
col.InsertNextValue(vtk.vtkVariant(0.0))
table.AddColumn(col)
# Fill the table with values
counter = 0
for r in range(0, table.GetNumberOfRows()):
for c in range(table.GetNumberOfColumns()):
table.SetValue(r, c, vtk.vtkVariant(counter))
counter += 1
writer = vtk.vtkDelimitedTextWriter()
writer.SetFileName(output_filename)
writer.SetInputData(table)
writer.Write()
def vtkVariantStrictWeakOrder(s1, s2):
"""
Compare variants by type first, and then by value. The return values
are -1, 0, 1 like the python cmp() method, for compatibility with the
python list sort() method. This is in contrast with the C++ version,
which returns true or false.
"""
s1 = vtkVariant(s1)
s2 = vtkVariant(s2)
t1 = s1.GetType()
t2 = s2.GetType()
# check based on type
if t1 != t2:
return cmp(t1,t2)
v1 = s1.IsValid()
v2 = s2.IsValid()
# check based on validity
if (not v1) and (not v2):
return 0
elif v1 != v2:
return cmp(v1,v2)
# extract and compare the values
r1 = getattr(s1, _variant_method_map[t1])()
r2 = getattr(s2, _variant_method_map[t2])()
# compare vtk objects by classname
if t1 == vtk.VTK_OBJECT:
return cmp(r1.GetClassName(), r2.GetClassName())
return cmp(r1, r2)
def vtkVariantStrictEquality(s1, s2):
"""
Check two variants for strict equality of type and value.
"""
s1 = vtk.vtkVariant(s1)
s2 = vtk.vtkVariant(s2)
t1 = s1.GetType()
t2 = s2.GetType()
# check based on type
if t1 != t2:
return False
v1 = s1.IsValid()
v2 = s2.IsValid()
# check based on validity
if (not v1) and (not v2):
return True
elif v1 != v2:
return False
# extract and compare the values
r1 = getattr(s1, _variant_method_map[t1])()
r2 = getattr(s2, _variant_method_map[t2])()
return (r1 == r2)
def testBoolPointer(self):
v = vtk.vtkVariant("1")
bp = [False]
d = v.ToFloat(bp)
self.assertEqual(bp, [True])
v = vtk.vtkVariant("George")
d = v.ToFloat(bp)
self.assertEqual(bp, [False])
def testStrictWeakOrder(self):
"""Use vtkVariantStrictWeakOrder to sort a list of vtkVariants"""
if not unicode_support:
return
l = map(vtk.vtkVariant, [1, 2.5, vtk.vtkVariant(), "0", u'hello'])
s = map(vtk.vtkVariant, [vtk.vtkVariant(), 1, 2.5, "0", u'hello'])
l.sort(vtk.vtkVariantStrictWeakOrder)
self.assertEqual(l, s)
def testCompare(self):
"""Use comparison operators to sort a list of vtkVariants"""
if not unicode_support:
return
l = map(vtk.vtkVariant, [1, 2.5, vtk.vtkVariant(), "0", u'hello'])
s = map(vtk.vtkVariant, [vtk.vtkVariant(), "0", 1, 2.5, u'hello'])
l.sort()
self.assertEqual(l, s)
def testCompare(self):
"""Use comparison operators to sort a list of vtkVariants"""
if not unicode_support:
return
l = map(vtk.vtkVariant, [1, 2.5, vtk.vtkVariant(), "0", u'hello'])
s = map(vtk.vtkVariant, [vtk.vtkVariant(), "0", 1, 2.5, u'hello'])
l.sort()
self.assertEqual(l, s)
def testStrictWeakOrder(self):
"""Use vtkVariantStrictWeakOrder to sort a list of vtkVariants"""
original = [1, 2.5, vtk.vtkVariant(), "0", cedilla]
ordered = [vtk.vtkVariant(), 1, 2.5, "0", cedilla]
l = [vtk.vtkVariant(x) for x in original]
s = [vtk.vtkVariant(x) for x in ordered]
l.sort(key=vtk.vtkVariantStrictWeakOrderKey)
self.assertEqual(l, s)
def testStrictWeakOrder(self):
"""Use vtkVariantStrictWeakOrder to sort a list of vtkVariants"""
if not unicode_support:
return
l = map(vtk.vtkVariant, [1, 2.5, vtk.vtkVariant(), "0", u'hello'])
s = map(vtk.vtkVariant, [vtk.vtkVariant(), 1, 2.5, "0", u'hello'])
l.sort(vtk.vtkVariantStrictWeakOrder)
self.assertEqual(l, s)
def testCompare(self):
"""Use comparison operators to sort a list of vtkVariants"""
original = [1, 2.5, vtk.vtkVariant(), "0", cedilla]
ordered = [vtk.vtkVariant(), "0", 1, 2.5, cedilla]
l = [vtk.vtkVariant(x) for x in original]
s = [vtk.vtkVariant(x) for x in ordered]
l.sort()
self.assertEqual(l, s)
def testStrictWeakOrder(self):
"""Use vtkVariantStrictWeakOrder to sort a list of vtkVariants"""
original = [1, 2.5, vtk.vtkVariant(), "0", cedilla]
ordered = [vtk.vtkVariant(), 1, 2.5, "0", cedilla]
l = [vtk.vtkVariant(x) for x in original]
s = [vtk.vtkVariant(x) for x in ordered]
l.sort(key=vtk.vtkVariantStrictWeakOrderKey)
self.assertEqual(l, s)
def testBoolPointer(self):
v = vtk.vtkVariant("1")
bp = [False]
d = v.ToFloat(bp)
self.assertEqual(bp, [True])
v = vtk.vtkVariant("George")
d = v.ToFloat(bp)
self.assertEqual(bp, [False])
def testCompare(self):
"""Use comparison operators to sort a list of vtkVariants"""
original = [1, 2.5, vtk.vtkVariant(), "0", cedilla]
ordered = [vtk.vtkVariant(), "0", 1, 2.5, cedilla]
l = [vtk.vtkVariant(x) for x in original]
s = [vtk.vtkVariant(x) for x in ordered]
l.sort()
self.assertEqual(l, s)
def testStrictWeakOrder(self):
"""Use vtkVariantStrictWeakOrder to sort a list of vtkVariants"""
if sys.hexversion > 0x03000000:
"""sort() doesn't take comparator in py3k"""
return
original = [1, 2.5, vtk.vtkVariant(), "0", cedilla]
ordered = [vtk.vtkVariant(), 1, 2.5, "0", cedilla]
l = [vtk.vtkVariant(x) for x in original]
s = [vtk.vtkVariant(x) for x in ordered]
l.sort(vtk.vtkVariantStrictWeakOrder)
self.assertEqual(l, s)
def Execute(self, obj, event):
del obj, event
interactor = self.Viewer.GetRenderWindow().GetInteractor()
renderer = self.Viewer.GetRenderer()
actor = self.Viewer.GetImageActor()
image = self.Viewer.GetInput()
style = interactor.GetInteractorStyle()
self.Picker.Pick(interactor.GetEventPosition()[0],
interactor.GetEventPosition()[1], 0.0, renderer)
path = self.Picker.GetPath() # Get iterator
validPick = False
if path is not None:
# TODO: Use pythonic iteration, need to get iterator for vtkAssemblePath
path.InitTraversal()
for i in range(path.GetNumberOfItems()):
node = path.GetNextNode()
if actor == node.GetViewProp():
validPick = True
break
if not validPick:
self.Annotation.SetText(0, "Off Image")
interactor.Render()
style.OnMouseMove()
return
pos = self.Picker.GetPickPosition()
axis = self.Viewer.GetSliceOrientation()
image_coordinates = [0, 0, 0]
if axis == vtk.vtkImageViewer2.SLICE_ORIENTATION_XZ:
image_coordinates[0] = int(vtk.vtkMath.Round(pos[0]))
image_coordinates[1] = int(self.Viewer.GetSlice())
image_coordinates[2] = int(vtk.vtkMath.Round(pos[2]))
elif axis == vtk.vtkImageViewer2.SLICE_ORIENTATION_YZ:
image_coordinates[0] = int(self.Viewer.GetSlice())
image_coordinates[1] = int(vtk.vtkMath.Round(pos[0]))
image_coordinates[2] = int(vtk.vtkMath.Round(pos[1]))
else:
image_coordinates[0] = int(vtk.vtkMath.Round(pos[0]))
image_coordinates[1] = int(vtk.vtkMath.Round(pos[1]))
image_coordinates[2] = int(self.Viewer.GetSlice())
message = "Location: ( "
message = message + vtk.vtkVariant(image_coordinates[0]).ToString()
message = message + ", "
message = message + vtk.vtkVariant(image_coordinates[1]).ToString()
message = message + ", "
message = message + vtk.vtkVariant(image_coordinates[2]).ToString()
message = message + " )\nValue: ( "
# We convert everything to float
message = valueMessage(image, image_coordinates, message)
self.Annotation.SetText(0, message)
interactor.Render()
style.OnMouseMove()
def testComparisonMethods(self):
v1 = vtk.vtkVariant(10)
v2 = vtk.vtkVariant("10")
# compare without regards to type
self.assertEqual(vtk.vtkVariantEqual(v1, v2), True)
self.assertEqual(vtk.vtkVariantLessThan(v1, v2), False)
# compare with different types being non-equivalent
self.assertEqual(vtk.vtkVariantStrictEquality(v1, v2), False)
if sys.hexversion >= 0x03000000:
self.assertEqual(vtk.vtkVariantStrictWeakOrder(v1, v2), True)
else:
# for Python 2, it worked like the cmp() function
self.assertEqual(vtk.vtkVariantStrictWeakOrder(v1, v2), -1)
def testComparisonMethods(self):
v1 = vtk.vtkVariant(10)
v2 = vtk.vtkVariant("10")
# compare without regards to type
self.assertEqual(vtk.vtkVariantEqual(v1, v2), True)
self.assertEqual(vtk.vtkVariantLessThan(v1, v2), False)
# compare with different types being non-equivalent
self.assertEqual(vtk.vtkVariantStrictEquality(v1, v2), False)
if sys.hexversion >= 0x03000000:
self.assertEqual(vtk.vtkVariantStrictWeakOrder(v1, v2), True)
else:
# for Python 2, it worked like the cmp() function
self.assertEqual(vtk.vtkVariantStrictWeakOrder(v1, v2), -1)
def testConstructors(self):
"""Test overloaded constructors"""
# resolve by number of arguments
v = vtk.vtkVector3d(3, 4, 5)
self.assertEqual((v[0], v[1], v[2]), (3, 4, 5))
v = vtk.vtkVector3d(6)
self.assertEqual((v[0], v[1], v[2]), (6, 6, 6))
# resolve by argument type
v = vtk.vtkVariant(3.0)
self.assertEqual(v.GetType(), vtk.VTK_DOUBLE)
v = vtk.vtkVariant(1)
self.assertEqual(v.GetType(), vtk.VTK_INT)
v = vtk.vtkVariant("hello")
self.assertEqual(v.GetType(), vtk.VTK_STRING)
v = vtk.vtkVariant(vtk.vtkObject())
self.assertEqual(v.GetType(), vtk.VTK_OBJECT)
def testConstructors(self):
"""Test overloaded constructors"""
# resolve by number of arguments
v = vtk.vtkVector3d(3, 4, 5)
self.assertEqual((v[0], v[1], v[2]), (3, 4, 5))
v = vtk.vtkVector3d(6)
self.assertEqual((v[0], v[1], v[2]), (6, 6, 6))
# resolve by argument type
v = vtk.vtkVariant(3.0)
self.assertEqual(v.GetType(), vtk.VTK_DOUBLE)
v = vtk.vtkVariant(1)
self.assertEqual(v.GetType(), vtk.VTK_INT)
v = vtk.vtkVariant("hello")
self.assertEqual(v.GetType(), vtk.VTK_STRING)
v = vtk.vtkVariant(vtk.vtkObject())
self.assertEqual(v.GetType(), vtk.VTK_OBJECT)
def testObjectConstructor(self):
"""Construct from VTK object"""
o = vtk.vtkIntArray()
v = vtk.vtkVariant(o)
self.assertEqual(v.GetType(), vtk.VTK_OBJECT)
self.assertEqual(v.GetTypeAsString(), o.GetClassName())
self.assertEqual(v.ToVTKObject(), o)
def testObjectConstructor(self):
"""Construct from VTK object"""
o = vtk.vtkIntArray()
v = vtk.vtkVariant(o)
self.assertEqual(v.GetType(), vtk.VTK_OBJECT)
self.assertEqual(v.GetTypeAsString(), o.GetClassName())
self.assertEqual(v.ToVTKObject(), o)
def vtkVariantStrictWeakOrder(s1, s2):
"""
Compare variants by type first, and then by value. When called from
within a Python 2 interpreter, the return values are -1, 0, 1 like the
cmp() method, for compatibility with the Python 2 list sort() method.
This is in contrast with the Python 3 version of this method (and the
VTK C++ version), which return true or false.
"""
s1 = vtk.vtkVariant(s1)
s2 = vtk.vtkVariant(s2)
t1 = s1.GetType()
t2 = s2.GetType()
# define a cmp(x, y) for Python 3 that returns (x < y)
def vcmp(x, y):
if sys.hexversion >= 0x03000000:
return (x < y)
else:
return cmp(x, y)
# check based on type
if t1 != t2:
return vcmp(t1, t2)
v1 = s1.IsValid()
v2 = s2.IsValid()
# check based on validity
if (not v1) or (not v2):
return vcmp(v1, v2)
# extract and compare the values
r1 = getattr(s1, _variant_method_map[t1])()
r2 = getattr(s2, _variant_method_map[t2])()
# compare vtk objects by classname, then address
if t1 == vtk.VTK_OBJECT:
c1 = r1.GetClassName()
c2 = r2.GetClassName()
if c1 != c2:
return vcmp(c1, c2)
else:
return vcmp(r1.__this__, r2.__this__)
return vcmp(r1, r2)
def vtkVariantStrictWeakOrder(s1, s2):
"""
Compare variants by type first, and then by value. When called from
within a Python 2 interpreter, the return values are -1, 0, 1 like the
cmp() method, for compatibility with the Python 2 list sort() method.
This is in contrast with the Python 3 version of this method (and the
VTK C++ version), which return true or false.
"""
s1 = vtk.vtkVariant(s1)
s2 = vtk.vtkVariant(s2)
t1 = s1.GetType()
t2 = s2.GetType()
# define a cmp(x, y) for Python 3 that returns (x < y)
def vcmp(x, y):
if sys.hexversion >= 0x03000000:
return (x < y)
else:
return cmp(x,y)
# check based on type
if t1 != t2:
return vcmp(t1,t2)
v1 = s1.IsValid()
v2 = s2.IsValid()
# check based on validity
if (not v1) or (not v2):
return vcmp(v1,v2)
# extract and compare the values
r1 = getattr(s1, _variant_method_map[t1])()
r2 = getattr(s2, _variant_method_map[t2])()
# compare vtk objects by classname, then address
if t1 == vtk.VTK_OBJECT:
c1 = r1.GetClassName()
c2 = r2.GetClassName()
if c1 != c2:
return vcmp(c1,c2)
else:
return vcmp(r1.__this__,r2.__this__)
return vcmp(r1, r2)
def testPassByValueReturnByReference(self):
"""Pass vtkVariant by value, return by reference"""
a = vtk.vtkVariantArray()
a.SetNumberOfValues(1)
v = vtk.vtkVariant(1)
a.SetValue(0, v)
u = a.GetValue(0)
self.assertEqual(u.ToInt(), v.ToInt())
self.assertEqual(u.GetType(), v.GetType())
self.assertEqual(u.IsValid(), v.IsValid())
def testPassByReferenceReturnByValue(self):
"""Pass vtkVariant by reference, return by value."""
a = vtk.vtkArray.CreateArray(1, vtk.VTK_INT)
a.Resize(1,1)
v = vtk.vtkVariant(1)
a.SetVariantValue(0, 0, v)
u = a.GetVariantValue(0, 0)
self.assertEqual(u.ToInt(), v.ToInt())
self.assertEqual(u.GetType(), v.GetType())
self.assertEqual(u.IsValid(), v.IsValid())
def testPassByValueReturnByReference(self):
"""Pass vtkVariant by value, return by reference"""
a = vtk.vtkVariantArray()
a.SetNumberOfValues(1)
v = vtk.vtkVariant(1)
a.SetValue(0, v)
u = a.GetValue(0)
self.assertEqual(u.ToInt(), v.ToInt())
self.assertEqual(u.GetType(), v.GetType())
self.assertEqual(u.IsValid(), v.IsValid())
def testPassByReferenceReturnByValue(self):
"""Pass vtkVariant by reference, return by value."""
a = vtk.vtkArray.CreateArray(1, vtk.VTK_INT)
a.Resize(1, 1)
v = vtk.vtkVariant(1)
a.SetVariantValue(0, 0, v)
u = a.GetVariantValue(0, 0)
self.assertEqual(u.ToInt(), v.ToInt())
self.assertEqual(u.GetType(), v.GetType())
self.assertEqual(u.IsValid(), v.IsValid())
def vtkVariantCreate(v, t):
"""
Create a vtkVariant of the specified type, where the type is in the
following format: 'int', 'unsigned int', etc. for numeric types,
and 'string' or 'unicode string' for strings. You can also use an
integer VTK type constant for the type.
"""
if not issubclass(type(t), int):
t = _variant_type_map[t]
return vtk.vtkVariant(v, t)
def vtkVariantCreate(v, t):
"""
Create a vtkVariant of the specified type, where the type is in the
following format: 'int', 'unsigned int', etc. for numeric types,
and 'string' or 'unicode string' for strings. You can also use an
integer VTK type constant for the type.
"""
if not issubclass(type(t), int):
t = _variant_type_map[t]
return vtk.vtkVariant(v, t)
def testArgumentConversion(self):
"""Test argument conversion via implicit constructors"""
# automatic conversion to vtkVariant
a = vtk.vtkVariantArray()
a.InsertNextValue(2.5)
a.InsertNextValue(vtk.vtkObject())
self.assertEqual(a.GetValue(0), vtk.vtkVariant(2.5))
self.assertEqual(a.GetValue(1).GetType(), vtk.VTK_OBJECT)
# same, but this one is via "const vtkVariant&" argument
a = vtk.vtkDenseArray[float]()
a.Resize(1)
a.SetVariantValue(0, 2.5)
self.assertEqual(a.GetVariantValue(0).ToDouble(), 2.5)
def testArgumentConversion(self):
"""Test argument conversion via implicit constructors"""
# automatic conversion to vtkVariant
a = vtk.vtkVariantArray()
a.InsertNextValue(2.5)
a.InsertNextValue(vtk.vtkObject())
self.assertEqual(a.GetValue(0), vtk.vtkVariant(2.5))
self.assertEqual(a.GetValue(1).GetType(), vtk.VTK_OBJECT)
# same, but this one is via "const vtkVariant&" argument
a = vtk.vtkDenseArray[float]()
a.Resize(1)
a.SetVariantValue(0, 2.5)
self.assertEqual(a.GetVariantValue(0).ToDouble(), 2.5)
def testHash(self):
"""Use a variant as a dict key"""
d = {}
# doubles, ints, strings, all hash as strings
d[vtk.vtkVariant(1.0)] = 'double'
d[vtk.vtkVariant(1)] = 'int'
self.assertEqual(d[vtk.vtkVariant('1')], 'int')
# every vtkObject is hashed by memory address
o1 = vtk.vtkIntArray()
o2 = vtk.vtkIntArray()
d[vtk.vtkVariant(o1)] = 'vtkIntArray1'
d[vtk.vtkVariant(o2)] = 'vtkIntArray2'
self.assertEqual(d[vtk.vtkVariant(o1)], 'vtkIntArray1')
self.assertEqual(d[vtk.vtkVariant(o2)], 'vtkIntArray2')
# invalid variants all hash the same
d[vtk.vtkVariant()] = 'invalid'
self.assertEqual(d[vtk.vtkVariant()], 'invalid')
def vtkVariantCast(v, t):
"""
Cast the vtkVariant to the specified value type, where the type is
in the following format: 'int', 'unsigned int', etc. for numeric types,
and 'string' or 'unicode string' for strings. You can also use an
integer VTK type constant for the type.
"""
if not issubclass(type(t), int):
t = _variant_type_map[t]
v = vtk.vtkVariant(v, t)
if v.IsValid():
return getattr(v, _variant_method_map[t])()
else:
return None
def vtkVariantCast(v, t):
"""
Cast the vtkVariant to the specified value type, where the type is
in the following format: 'int', 'unsigned int', etc. for numeric types,
and 'string' or 'unicode string' for strings. You can also use an
integer VTK type constant for the type.
"""
if not issubclass(type(t), int):
t = _variant_type_map[t]
v = vtk.vtkVariant(v, t)
if v.IsValid():
return getattr(v, _variant_method_map[t])()
else:
return None
def vtkVariantExtract(v, t=None):
"""
Extract the specified value type from the vtkVariant, where the type is
in the following format: 'int', 'unsigned int', etc. for numeric types,
and 'string' or 'unicode string' for strings. You can also use an
integer VTK type constant for the type. Set the type to 'None" to
extract the value in its native type.
"""
v = vtk.vtkVariant(v)
if t == None:
t = v.GetType()
elif not issubclass(type(t), int):
t = _variant_type_map[t]
if getattr(v, _variant_check_map[t])():
return getattr(v, _variant_method_map[t])()
else:
return None
def vtkVariantExtract(v, t=None):
"""
Extract the specified value type from the vtkVariant, where the type is
in the following format: 'int', 'unsigned int', etc. for numeric types,
and 'string' or 'unicode string' for strings. You can also use an
integer VTK type constant for the type. Set the type to 'None" to
extract the value in its native type.
"""
v = vtk.vtkVariant(v)
if t == None:
t = v.GetType()
elif not issubclass(type(t), int):
t = _variant_type_map[t]
if getattr(v, _variant_check_map[t])():
return getattr(v, _variant_method_map[t])()
else:
return None
def testSparseArray(self):
"""Test vtkSparseArray template"""
for t in arrayTypes + arrayCodes:
a = vtk.vtkSparseArray[t]()
a.Resize(1)
i = vtk.vtkArrayCoordinates(0)
if t in ["bool", "?"]:
value = 0
a.SetValue(i, value)
result = a.GetValue(i)
self.assertEqual(value, result)
elif t in ["float32", "float64", "float", "f", "d"]:
value = 3.125
a.SetValue(i, value)
result = a.GetValue(i)
self.assertEqual(value, result)
elif t in ["char", "c"]:
value = "c"
a.SetValue(i, value)
result = a.GetValue(i)
self.assertEqual(value, result)
elif t in [str, "str"]:
value = "hello"
a.SetValue(i, value)
result = a.GetValue(i)
self.assertEqual(value, result)
elif t in ["unicode"]:
value = francois
a.SetValue(i, value)
result = a.GetValue(i)
self.assertEqual(value, result)
elif t in ["vtkVariant", vtk.vtkVariant]:
value = vtk.vtkVariant("world")
a.SetValue(i, value)
result = a.GetValue(i)
self.assertEqual(value, result)
else:
value = 12
a.SetValue(i, value)
result = a.GetValue(i)
self.assertEqual(value, result)
def testSparseArray(self):
"""Test vtkSparseArray template"""
for t in (arrayTypes + arrayCodes):
a = vtk.vtkSparseArray[t]()
a.Resize(1)
i = vtk.vtkArrayCoordinates(0)
if t in ['bool', '?']:
value = 0
a.SetValue(i, value)
result = a.GetValue(i)
self.assertEqual(value, result)
elif t in ['float32', 'float64', 'float', 'f', 'd']:
value = 3.125
a.SetValue(i, value)
result = a.GetValue(i)
self.assertEqual(value, result)
elif t in ['char', 'c']:
value = 'c'
a.SetValue(i, value)
result = a.GetValue(i)
self.assertEqual(value, result)
elif t in [str, 'str']:
value = "hello"
a.SetValue(i, value)
result = a.GetValue(i)
self.assertEqual(value, result)
elif t in ['unicode']:
value = francois
a.SetValue(i, value)
result = a.GetValue(i)
self.assertEqual(value, result)
elif t in ['vtkVariant', vtk.vtkVariant]:
value = vtk.vtkVariant("world")
a.SetValue(i, value)
result = a.GetValue(i)
self.assertEqual(value, result)
else:
value = 12
a.SetValue(i, value)
result = a.GetValue(i)
self.assertEqual(value, result)
def testAutomaticArgConversion(self):
"""Automatic construction of variants to resolve args"""
# use with one of vtkVariant's own constructors
v = vtk.vtkVariant('10', vtk.VTK_INT)
self.assertEqual(v.ToInt(), 10)
self.assertEqual(v.GetType(), vtk.VTK_INT)
# use with vtkVariantArray
a = vtk.vtkVariantArray()
i = a.InsertNextValue(10)
v = a.GetValue(i)
self.assertEqual(v.GetType(), vtk.VTK_INT)
self.assertEqual(v.ToInt(), 10)
i = a.InsertNextValue(10.0)
v = a.GetValue(i)
self.assertEqual(v.GetType(), vtk.VTK_DOUBLE)
self.assertEqual(v.ToDouble(), 10.0)
i = a.InsertNextValue('10')
v = a.GetValue(i)
self.assertEqual(v.GetType(), vtk.VTK_STRING)
self.assertEqual(v.ToString(), '10')
def testAutomaticArgConversion(self):
"""Automatic construction of variants to resolve args"""
# use with one of vtkVariant's own constructors
v = vtk.vtkVariant('10', vtk.VTK_INT)
self.assertEqual(v.ToInt(), 10)
self.assertEqual(v.GetType(), vtk.VTK_INT)
# use with vtkVariantArray
a = vtk.vtkVariantArray()
i = a.InsertNextValue(10)
v = a.GetValue(i)
self.assertEqual(v.GetType(), vtk.VTK_INT)
self.assertEqual(v.ToInt(), 10)
i = a.InsertNextValue(10.0)
v = a.GetValue(i)
self.assertEqual(v.GetType(), vtk.VTK_DOUBLE)
self.assertEqual(v.ToDouble(), 10.0)
i = a.InsertNextValue('10')
v = a.GetValue(i)
self.assertEqual(v.GetType(), vtk.VTK_STRING)
self.assertEqual(v.ToString(), '10')
def testTwoArgConstructor(self):
"""Construct with a specific type"""
# construct with conversion to int
v = vtk.vtkVariant('10')
u = vtk.vtkVariant(v, vtk.VTK_INT)
self.assertEqual(u.GetType(), vtk.VTK_INT)
self.assertEqual(v.ToInt(), u.ToInt())
# construct with conversion to double
v = vtk.vtkVariant(10)
u = vtk.vtkVariant(v, vtk.VTK_DOUBLE)
self.assertEqual(u.GetType(), vtk.VTK_DOUBLE)
self.assertEqual(u.ToDouble(), 10.0)
# failed conversion to vtkObject
v = vtk.vtkVariant(10)
u = vtk.vtkVariant(v, vtk.VTK_OBJECT)
self.assertEqual(u.IsValid(), False)
def testTwoArgConstructor(self):
"""Construct with a specific type"""
# construct with conversion to int
v = vtk.vtkVariant('10')
u = vtk.vtkVariant(v, vtk.VTK_INT)
self.assertEqual(u.GetType(), vtk.VTK_INT)
self.assertEqual(v.ToInt(), u.ToInt())
# construct with conversion to double
v = vtk.vtkVariant(10)
u = vtk.vtkVariant(v, vtk.VTK_DOUBLE)
self.assertEqual(u.GetType(), vtk.VTK_DOUBLE)
self.assertEqual(u.ToDouble(), 10.0)
# failed conversion to vtkObject
v = vtk.vtkVariant(10)
u = vtk.vtkVariant(v, vtk.VTK_OBJECT)
self.assertEqual(u.IsValid(), False)
def testSparseArray(self):
"""Test vtkSparseArray template"""
for t in (arrayTypes + arrayCodes):
a = vtk.vtkSparseArray[t]()
a.Resize(1)
i = vtk.vtkArrayCoordinates(0)
if t in ['bool', '?']:
value = 0
a.SetValue(i, value)
result = a.GetValue(i)
self.assertEqual(value, result)
elif t in ['float32', 'float64', 'float', 'f', 'd']:
value = 3.125
a.SetValue(i, value)
result = a.GetValue(i)
self.assertEqual(value, result)
elif t in ['char', 'c']:
value = 'c'
a.SetValue(i, value)
result = a.GetValue(i)
self.assertEqual(value, result)
elif t in [str, 'str', 'unicode']:
value = unicode("hello")
a.SetValue(i, value)
result = a.GetValue(i)
self.assertEqual(value, result)
elif t in ['vtkVariant', vtk.vtkVariant]:
value = vtk.vtkVariant("world")
a.SetValue(i, value)
result = a.GetValue(i)
self.assertEqual(value, result)
else:
value = 12
a.SetValue(i, value)
result = a.GetValue(i)
self.assertEqual(value, result)
def testFloatConstructor(self):
"""Construct from float"""
v = vtk.vtkVariant(10.0)
self.assertEqual(v.GetType(), vtk.VTK_DOUBLE)
self.assertEqual(v.ToDouble(), 10.0)
def testDefaultConstructor(self):
"""Default constructor"""
v = vtk.vtkVariant()
self.assertEqual(v.IsValid(), False)
self.assertEqual(v.GetType(), 0)
def vtkVariantEqual(s1, s2):
"""
Return true if s1 == s2.
"""
return (vtk.vtkVariant(s1) == vtk.vtkVariant(s2))
def vtkVariantLessThan(s1, s2):
"""
Return true if s1 < s2.
"""
return (vtk.vtkVariant(s1) < vtk.vtkVariant(s2))
def testFloatConstructor(self):
"""Construct from float"""
v = vtk.vtkVariant(10.0)
self.assertEqual(v.GetType(), vtk.VTK_DOUBLE)
self.assertEqual(v.ToDouble(), 10.0)
"geometry": {
"type": "Polygon",
"coordinates": [
[ [100.0, 0.0], [101.0, 0.0], [101.0, 1.0],
[100.0, 1.0], [100.0, 0.0] ]
]
},
"properties": {
"prop0": "value0",
"prop1": {"this": "that"}
}
}
]
}
"""
prop0_default = vtk.vtkVariant('default')
feature_properties = {'prop0': prop0_default}
polydata = load_geojson(input_string, feature_properties)
if polydata is None:
print 'Failed to read input string and return vtkPolyData'
sys.exit(1)
num_errors = 0
# Check cell counts
expected_verts = 1
expected_lines = 3
expected_polys = 1
num_verts = polydata.GetNumberOfVerts()
if num_verts != expected_verts:
def DisplaySurface(st):
'''
Make and display the surface.
:param: st - the surface to display.
:return The vtkRenderWindowInteractor.
'''
surface = st.upper()
if (not(surface in SURFACE_TYPE) ):
print st, "is not a surface."
iren = vtk.vtkRenderWindowInteractor()
return iren
# ------------------------------------------------------------
# Create the surface, lookup tables, contour filter etc.
# ------------------------------------------------------------
src = vtk.vtkPolyData()
if (surface == "TORUS"):
src = MakeTorus()
elif (surface == "PARAMETRIC_TORUS"):
src = MakeParametricTorus()
elif (surface == "PARAMETRIC_HILLS"):
src = Clipper(MakeParametricHills(),0.5,0.5,0.0)
# Here we are assuming that the active scalars are the curvatures.
curvatureName = src.GetPointData().GetScalars().GetName()
# Use this range to color the glyphs for the normals by elevation.
src.GetPointData().SetActiveScalars('Elevation')
scalarRangeElevation = src.GetScalarRange()
src.GetPointData().SetActiveScalars(curvatureName)
scalarRangeCurvatures = src.GetScalarRange()
scalarRange = scalarRangeCurvatures
lut = MakeLUT()
numberOfBands = lut.GetNumberOfTableValues()
bands = MakeBands(scalarRange, numberOfBands, False)
if surface == "PARAMETRIC_HILLS":
# Comment this out if you want to see how allocating
# equally spaced bands works.
bands = MakeCustomBands(scalarRange, numberOfBands)
# Adjust the number of table values
numberOfBands = len(bands)
lut.SetNumberOfTableValues(numberOfBands)
lut.SetTableRange(scalarRange)
# We will use the midpoint of the band as the label.
labels = []
for i in range(numberOfBands):
labels.append('{:4.2f}'.format(bands[i][1]))
# Annotate
values = vtk.vtkVariantArray()
for i in range(len(labels)):
values.InsertNextValue(vtk.vtkVariant(labels[i]))
for i in range(values.GetNumberOfTuples()):
lut.SetAnnotation(i, values.GetValue(i).ToString());
# Create a lookup table with the colors reversed.
lutr = ReverseLUT(lut)
# Create the contour bands.
bcf = vtk.vtkBandedPolyDataContourFilter()
bcf.SetInputData(src)
# Use either the minimum or maximum value for each band.
for i in range(0, numberOfBands):
bcf.SetValue(i, bands[i][2])
# We will use an indexed lookup table.
bcf.SetScalarModeToIndex()
bcf.GenerateContourEdgesOn()
# Generate the glyphs on the original surface.
glyph = MakeGlyphs(src,False)
# ------------------------------------------------------------
# Create the mappers and actors
# ------------------------------------------------------------
srcMapper = vtk.vtkPolyDataMapper()
srcMapper.SetInputConnection(bcf.GetOutputPort())
srcMapper.SetScalarRange(scalarRange)
srcMapper.SetLookupTable(lut)
srcMapper.SetScalarModeToUseCellData()
srcActor = vtk.vtkActor()
srcActor.SetMapper(srcMapper)
srcActor.RotateX(-45)
srcActor.RotateZ(45)
# Create contour edges
edgeMapper = vtk.vtkPolyDataMapper()
edgeMapper.SetInputData(bcf.GetContourEdgesOutput())
edgeMapper.SetResolveCoincidentTopologyToPolygonOffset()
edgeActor = vtk.vtkActor()
edgeActor.SetMapper(edgeMapper)
edgeActor.GetProperty().SetColor(0, 0, 0)
edgeActor.RotateX(-45)
edgeActor.RotateZ(45)
glyphMapper = vtk.vtkPolyDataMapper()
glyphMapper.SetInputConnection(glyph.GetOutputPort())
glyphMapper.SetScalarModeToUsePointFieldData()
glyphMapper.SetColorModeToMapScalars()
glyphMapper.ScalarVisibilityOn()
glyphMapper.SelectColorArray('Elevation')
# Colour by scalars.
glyphMapper.SetScalarRange(scalarRangeElevation)
glyphActor = vtk.vtkActor()
glyphActor.SetMapper(glyphMapper)
glyphActor.RotateX(-45)
glyphActor.RotateZ(45)
# Add a scalar bar.
scalarBar = vtk.vtkScalarBarActor()
# This LUT puts the lowest value at the top of the scalar bar.
# scalarBar->SetLookupTable(lut);
# Use this LUT if you want the highest value at the top.
scalarBar.SetLookupTable(lutr)
scalarBar.SetTitle('Gaussian\nCurvature')
# ------------------------------------------------------------
# Create the RenderWindow, Renderer and Interactor
# ------------------------------------------------------------
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
iren = vtk.vtkRenderWindowInteractor()
renWin.AddRenderer(ren)
iren.SetRenderWindow(renWin)
# add actors
ren.AddViewProp(srcActor)
ren.AddViewProp(edgeActor)
ren.AddViewProp(glyphActor)
ren.AddActor2D(scalarBar)
ren.SetBackground(0.7, 0.8, 1.0)
renWin.SetSize(800, 800)
renWin.Render()
ren.GetActiveCamera().Zoom(1.5)
return iren
def DisplaySurface(st):
'''
Make and display the surface.
:param: st - the surface to display.
:return The vtkRenderWindowInteractor.
'''
surface = st.upper()
if (not (surface in SURFACE_TYPE)):
print st, "is not a surface."
iren = vtk.vtkRenderWindowInteractor()
return iren
# ------------------------------------------------------------
# Create the surface, lookup tables, contour filter etc.
# ------------------------------------------------------------
src = vtk.vtkPolyData()
if (surface == "PLANE"):
src = MakePlane()
elif (surface == "SPHERE"):
src = MakeSphere()
elif (surface == "PARAMETRIC_SURFACE"):
src = MakeParametricSource()
# The scalars are named "Scalars"by default
# in the parametric surfaces, so change the name.
src.GetPointData().GetScalars().SetName("Elevation")
scalarRange = src.GetScalarRange()
lut = MakeLUT()
lut.SetTableRange(scalarRange)
numberOfBands = lut.GetNumberOfTableValues()
# bands = MakeIntegralBands(scalarRange)
bands = MakeBands(scalarRange, numberOfBands, False)
# Let's do a frequency table.
# The number of scalars in each band.
#print Frequencies(bands, src)
# We will use the midpoint of the band as the label.
labels = []
for i in range(len(bands)):
labels.append('{:4.2f}'.format(bands[i][1]))
# Annotate
values = vtk.vtkVariantArray()
for i in range(len(labels)):
values.InsertNextValue(vtk.vtkVariant(labels[i]))
for i in range(values.GetNumberOfTuples()):
lut.SetAnnotation(i,
values.GetValue(i).ToString())
# Create a lookup table with the colors reversed.
lutr = ReverseLUT(lut)
# Create the contour bands.
bcf = vtk.vtkBandedPolyDataContourFilter()
bcf.SetInputData(src)
# Use either the minimum or maximum value for each band.
for i in range(0, numberOfBands):
bcf.SetValue(i, bands[i][2])
# We will use an indexed lookup table.
bcf.SetScalarModeToIndex()
bcf.GenerateContourEdgesOn()
# Generate the glyphs on the original surface.
glyph = MakeGlyphs(src, False)
# ------------------------------------------------------------
# Create the mappers and actors
# ------------------------------------------------------------
srcMapper = vtk.vtkPolyDataMapper()
srcMapper.SetInputConnection(bcf.GetOutputPort())
srcMapper.SetScalarRange(scalarRange)
srcMapper.SetLookupTable(lut)
srcMapper.SetScalarModeToUseCellData()
srcActor = vtk.vtkActor()
srcActor.SetMapper(srcMapper)
srcActor.RotateX(-45)
srcActor.RotateZ(45)
# Create contour edges
edgeMapper = vtk.vtkPolyDataMapper()
edgeMapper.SetInputData(bcf.GetContourEdgesOutput())
edgeMapper.SetResolveCoincidentTopologyToPolygonOffset()
edgeActor = vtk.vtkActor()
edgeActor.SetMapper(edgeMapper)
edgeActor.GetProperty().SetColor(0, 0, 0)
edgeActor.RotateX(-45)
edgeActor.RotateZ(45)
glyphMapper = vtk.vtkPolyDataMapper()
glyphMapper.SetInputConnection(glyph.GetOutputPort())
glyphMapper.SetScalarModeToUsePointFieldData()
glyphMapper.SetColorModeToMapScalars()
glyphMapper.ScalarVisibilityOn()
glyphMapper.SelectColorArray('Elevation')
# Colour by scalars.
glyphMapper.SetScalarRange(scalarRange)
glyphActor = vtk.vtkActor()
glyphActor.SetMapper(glyphMapper)
glyphActor.RotateX(-45)
glyphActor.RotateZ(45)
# Add a scalar bar.
scalarBar = vtk.vtkScalarBarActor()
# scalarBar.SetLookupTable(lut)
# Use this LUT if you want the highest value at the top.
scalarBar.SetLookupTable(lutr)
scalarBar.SetTitle('Elevation (m)')
# ------------------------------------------------------------
# Create the RenderWindow, Renderer and Interactor
# ------------------------------------------------------------
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
iren = vtk.vtkRenderWindowInteractor()
renWin.AddRenderer(ren)
iren.SetRenderWindow(renWin)
# add actors
ren.AddViewProp(srcActor)
ren.AddViewProp(edgeActor)
ren.AddViewProp(glyphActor)
ren.AddActor2D(scalarBar)
ren.SetBackground(0.7, 0.8, 1.0)
renWin.SetSize(800, 800)
renWin.Render()
ren.GetActiveCamera().Zoom(1.5)
return iren
def testCopyConstructor(self):
"""Construct from another vtkVariant"""
u = vtk.vtkVariant('test')
v = vtk.vtkVariant(u)
self.assertEqual(v.GetType(), vtk.VTK_STRING)
self.assertEqual(v.ToString(), u.ToString())
def testStringConstructor(self):
"""Construct from string"""
v = vtk.vtkVariant('hello')
self.assertEqual(v.GetType(), vtk.VTK_STRING)
self.assertEqual(v.ToString(), 'hello')
def testUnicodeConstructor(self):
"""Construct from unicode"""
v = vtk.vtkVariant(cedilla)
self.assertEqual(v.GetType(), vtk.VTK_UNICODE_STRING)
self.assertEqual(v.ToUnicodeString(), cedilla)
def testBytesConstructor(self):
"""Construct from bytes"""
v = vtk.vtkVariant(b'hello')
self.assertEqual(v.GetType(), vtk.VTK_STRING)
self.assertEqual(v.ToString(), 'hello')
def testIntConstructor(self):
"""Construct from int"""
v = vtk.vtkVariant(10)
self.assertEqual(v.GetType(), vtk.VTK_INT)
self.assertEqual(v.ToInt(), 10)
def testUnicodeConstructor(self):
"""Construct from unicode"""
if unicode_support:
v = vtk.vtkVariant(u'hello')
self.assertEqual(v.GetType(), vtk.VTK_UNICODE_STRING)
self.assertEqual(v.ToUnicodeString(), u'hello')
