Python vtk.vtkVariant函数代码示例

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 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 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"""
     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 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 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"""
     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 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 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 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 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 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)