Differential D319 Diff 1982 release/scripts/freestyle/modules/freestyle/predicates.py

Changeset View

Standalone View

release/scripts/freestyle/modules/freestyle/predicates.py

Context not available.
	pyDensityAnisotropyF1D,	pyDensityAnisotropyF1D,
	pyViewMapGradientNormF1D,	pyViewMapGradientNormF1D,
	)	)

	import random	import random


	## Unary predicates for 0D elements (vertices)	# -- Unary predicates for 0D elements (vertices) -- #
	##############################################

	class pyHigherCurvature2DAngleUP0D(UnaryPredicate0D):	class pyHigherCurvature2DAngleUP0D(UnaryPredicate0D):
	def __init__(self,a):	def __init__(self, a):
	UnaryPredicate0D.__init__(self)	UnaryPredicate0D.__init__(self)
	self._a = a	self._a = a

Context not available.


	class pyUEqualsUP0D(UnaryPredicate0D):	class pyUEqualsUP0D(UnaryPredicate0D):
	def __init__(self,u, w):	def __init__(self, u, w):
	UnaryPredicate0D.__init__(self)	UnaryPredicate0D.__init__(self)
	self._u = u	self._u = u
	self._w = w	self._w = w
		self._func = pyCurvilinearLengthF0D()

	def __call__(self, inter):	def __call__(self, inter):
		kjym3Unsubmitted Not Done Inline Actions We could create the functor object in `__init__()` (e.g., self._getLength) and reuse it in `__call__`. That should be faster than instantiating the functor at every 0D element. kjym3: We could create the functor object in `__init__()` (e.g., self._getLength) and reuse it in…
	func = pyCurvilinearLengthF0D()	u = self._func(inter)
	u = func(inter)	return (u > (self._u - self._w)) and (u < (self._u + self._w))
	return (u > (self._u-self._w)) and (u < (self._u+self._w))


	class pyVertexNatureUP0D(UnaryPredicate0D):	class pyVertexNatureUP0D(UnaryPredicate0D):
Context not available.
	self._nature = nature	self._nature = nature

	def __call__(self, inter):	def __call__(self, inter):
	v = inter.object	return bool(inter.object.nature & self._nature)
	return (v.nature & self._nature) != 0


	## check whether an Interface0DIterator
	## is a TVertex and is the one that is
	## hidden (inferred from the context)
	class pyBackTVertexUP0D(UnaryPredicate0D):	class pyBackTVertexUP0D(UnaryPredicate0D):
		"""
		Check whether an Interface0DIterator
		references a TVertex and is the one that is
		hidden (inferred from the context)
		"""
	def __init__(self):	def __init__(self):
	UnaryPredicate0D.__init__(self)	UnaryPredicate0D.__init__(self)
	self._getQI = QuantitativeInvisibilityF0D()	self._getQI = QuantitativeInvisibilityF0D()

	def __call__(self, iter):	def __call__(self, iter):
	if (iter.object.nature & Nature.T_VERTEX) == 0:	if not (iter.object.nature & Nature.T_VERTEX) or iter.is_end:
	return False	return False
	if iter.is_end:	return self._getQI(iter) != 0
	return False
	if self._getQI(iter) != 0:
	return True
	return False

		kjym3Unsubmitted Not Done Inline Actions The original notation `qi != 0` seems more logical. kjym3: The original notation `qi != 0` seems more logical.

	class pyParameterUP0DGoodOne(UnaryPredicate0D):	class pyParameterUP0DGoodOne(UnaryPredicate0D):
Context not available.

	def __call__(self, inter):	def __call__(self, inter):
	u = inter.u	u = inter.u
	return ((u>=self._m) and (u<=self._M))	return ((u >= self._m) and (u <= self._M))


	class pyParameterUP0D(UnaryPredicate0D):	class pyParameterUP0D(UnaryPredicate0D):
Context not available.
	UnaryPredicate0D.__init__(self)	UnaryPredicate0D.__init__(self)
	self._m = pmin	self._m = pmin
	self._M = pmax	self._M = pmax
		self._func = Curvature2DAngleF0D()

	def __call__(self, inter):	def __call__(self, inter):
	func = Curvature2DAngleF0D()	c = self._func(inter)
	c = func(inter)	b1 = (c > 0.1)
	b1 = (c>0.1)
	u = inter.u	u = inter.u
		kjym3Unsubmitted Not Done Inline Actions Same as the previous comment in line 98. kjym3: Same as the previous comment in line 98.
	b = ((u>=self._m) and (u<=self._M))	b = ((u >= self._m) and (u <= self._M))
	return b and b1	return (b and b1)

	## Unary predicates for 1D elements (curves)	# -- Unary predicates for 1D elements (curves) -- #
	############################################

	class AndUP1D(UnaryPredicate1D):	class AndUP1D(UnaryPredicate1D):
	def __init__(self, pred1, pred2):	def __init__(self, *predicates):
	UnaryPredicate1D.__init__(self)	UnaryPredicate1D.__init__(self)
	self.__pred1 = pred1	self.predicates = predicates
	self.__pred2 = pred2	if len(self.predicates) < 2:
		raise ValueError("Expected two or more UnaryPredicate1D")

	def __call__(self, inter):	def __call__(self, inter):
	return self.__pred1(inter) and self.__pred2(inter)	return all(pred(inter) for pred in self.predicates)


		kjym3Unsubmitted Not Done Inline Actions This `if` block seems wrong. How about adding an argument check in `__init__()` to make sure the self.predicates have two or more predicates, and raise a ValueError if that is not the case? kjym3: This `if` block seems wrong. How about adding an argument check in `__init__()` to make sure…
	class OrUP1D(UnaryPredicate1D):	class OrUP1D(UnaryPredicate1D):
	def __init__(self, pred1, pred2):	def __init__(self, *predicates):
	UnaryPredicate1D.__init__(self)	UnaryPredicate1D.__init__(self)
	self.__pred1 = pred1	self.predicates = predicates
	self.__pred2 = pred2	if len(self.predicates) < 2:
		raise ValueError("Expected two or more UnaryPredicate1D")

	def __call__(self, inter):	def __call__(self, inter):
	return self.__pred1(inter) or self.__pred2(inter)	return any(pred(inter) for pred in self.predicates)


		kjym3Unsubmitted Not Done Inline Actions Same as the previous comment in line 165. kjym3: Same as the previous comment in line 165.
	class NotUP1D(UnaryPredicate1D):	class NotUP1D(UnaryPredicate1D):
Context not available.
	def __call__(self, inter):	def __call__(self, inter):
	return not self.__pred(inter)	return not self.__pred(inter)

		class ObjectNamesUP1D(UnaryPredicate1D):
		def __init__(self, names, negative=False):
		UnaryPredicate1D.__init__(self)
		self._names = names
		self._negative = negative

		def __call__(self, viewEdge):
		found = viewEdge.viewshape.name in self._names
		return found if not self._negative else not found

		class QuantitativeInvisibilityRangeUP1D(UnaryPredicate1D):
		def __init__(self, qi_start, qi_end):
		UnaryPredicate1D.__init__(self)
		self.__getQI = QuantitativeInvisibilityF1D()
		self.__qi_start = qi_start
		self.__qi_end = qi_end

		def __call__(self, inter):
		qi = self.__getQI(inter)
		return (self.__qi_start <= qi <= self.__qi_end)

	class pyNFirstUP1D(UnaryPredicate1D):	class pyNFirstUP1D(UnaryPredicate1D):
	def __init__(self, n):	def __init__(self, n):
Context not available.
	self.__count = 0	self.__count = 0

	def __call__(self, inter):	def __call__(self, inter):
	self.__count = self.__count + 1	self.__count += 1
	if self.__count <= self.__n:	return (self.__count <= self.__n)
	return True
	return False


	class pyHigherLengthUP1D(UnaryPredicate1D):	class pyHigherLengthUP1D(UnaryPredicate1D):
	def __init__(self,l):	def __init__(self, l):
	UnaryPredicate1D.__init__(self)	UnaryPredicate1D.__init__(self)
	self._l = l	self._l = l

Context not available.
	self._getNature = CurveNatureF1D()	self._getNature = CurveNatureF1D()

	def __call__(self, inter):	def __call__(self, inter):
	if(self._getNature(inter) & self._nature):	return bool(self._getNature(inter) & self._nature)
	return True
	return False


	class pyHigherNumberOfTurnsUP1D(UnaryPredicate1D):	class pyHigherNumberOfTurnsUP1D(UnaryPredicate1D):
	def __init__(self,n,a):	def __init__(self, n, a):
	UnaryPredicate1D.__init__(self)	UnaryPredicate1D.__init__(self)
	self._n = n	self._n = n
	self._a = a	self._a = a

	def __call__(self, inter):	def __call__(self, inter):
	count = 0
	func = Curvature2DAngleF0D()	func = Curvature2DAngleF0D()
	it = inter.vertices_begin()	it = inter.vertices_begin()
	while not it.is_end:	# sum the turns, check against n
		kjym3Unsubmitted Not Done Inline Actions I liked the expression `sum(1 for ve in it if func(it) > self._a)` in a previous revision. Is there any reason the new form is preferable? kjym3: I liked the expression `sum(1 for ve in it if func(it) > self._a)` in a previous revision. Is…
	if func(it) > self._a:	return sum(1 for ve in it if func(it) > self._a) > self._n
	count = count+1
	if count > self._n:
	return True
	it.increment()
	return False


	class pyDensityUP1D(UnaryPredicate1D):	class pyDensityUP1D(UnaryPredicate1D):
Context not available.
	def __init__(self, threshold, level, integration=IntegrationType.MEAN):	def __init__(self, threshold, level, integration=IntegrationType.MEAN):
	UnaryPredicate1D.__init__(self)	UnaryPredicate1D.__init__(self)
	self._threshold = threshold	self._threshold = threshold
	self._level = level	self._func = GetSteerableViewMapDensityF1D(level, integration)
	self._integration = integration
	self._func = GetSteerableViewMapDensityF1D(self._level, self._integration)

	def __call__(self, inter):	def __call__(self, inter):
	return (self._func(inter) > self._threshold)	return (self._func(inter) > self._threshold)
Context not available.
	def __init__(self, threshold, orientation, level, integration=IntegrationType.MEAN, sampling=2.0):	def __init__(self, threshold, orientation, level, integration=IntegrationType.MEAN, sampling=2.0):
	UnaryPredicate1D.__init__(self)	UnaryPredicate1D.__init__(self)
	self._threshold = threshold	self._threshold = threshold
	self._orientation = orientation	self._func = GetDirectionalViewMapDensityF1D(orientation, level, integration, sampling)
	self._level = level
	self._integration = integration
	self._sampling = sampling

	def __call__(self, inter):	def __call__(self, inter):
	func = GetDirectionalViewMapDensityF1D(self._orientation, self._level, self._integration, self._sampling)	return (self.func(inter) > self._threshold)
	return (func(inter) > self._threshold)


	class pyHighViewMapDensityUP1D(UnaryPredicate1D):	class pyHighViewMapDensityUP1D(UnaryPredicate1D):
	def __init__(self, threshold, level, integration=IntegrationType.MEAN, sampling=2.0):	def __init__(self, threshold, level, integration=IntegrationType.MEAN, sampling=2.0):
	UnaryPredicate1D.__init__(self)	UnaryPredicate1D.__init__(self)
	self._threshold = threshold	self._threshold = threshold
	self._level = level	self._func = GetCompleteViewMapDensityF1D(level, integration, sampling)
	self._integration = integration
	self._sampling = sampling
	self._func = GetCompleteViewMapDensityF1D(self._level, self._integration, self._sampling) # 2.0 is the smpling

	def __call__(self, inter):	def __call__(self, inter):
	return (self._func(inter) > self._threshold)	return (self._func(inter) > self._threshold)
Context not available.
	class pyDensityFunctorUP1D(UnaryPredicate1D):	class pyDensityFunctorUP1D(UnaryPredicate1D):
		kjym3Unsubmitted Not Done Inline Actions Is `inter.object` correct? (cf. the original code) kjym3: Is `inter.object` correct? (cf. the original code)
		flokkievidsAuthorUnsubmitted Not Done Inline Actions it is not correct. probably forgot that while testing. using self._func(inter) will however result in an infinite loop printing "this viewmap does not exist", alike most, if not all, ...Viewmap...-methods. because of this i've ommited it from my tests. flokkievids: it is not correct. probably forgot that while testing. using self._func(inter) will however…
	def __init__(self, wsize, threshold, functor, funcmin=0.0, funcmax=1.0, integration=IntegrationType.MEAN):	def __init__(self, wsize, threshold, functor, funcmin=0.0, funcmax=1.0, integration=IntegrationType.MEAN):
	UnaryPredicate1D.__init__(self)	UnaryPredicate1D.__init__(self)
	self._wsize = wsize
	self._threshold = float(threshold)	self._threshold = float(threshold)
	self._functor = functor	self._functor = functor
	self._funcmin = float(funcmin)	self._funcmin = float(funcmin)
	self._funcmax = float(funcmax)	self._funcmax = float(funcmax)
	self._integration = integration	self._func = DensityF1D(wsize, integration)

	def __call__(self, inter):	def __call__(self, inter):
	func = DensityF1D(self._wsize, self._integration)
	res = self._functor(inter)	res = self._functor(inter)
	k = (res-self._funcmin)/(self._funcmax-self._funcmin)	k = (res - self._funcmin) / (self._funcmax - self._funcmin)
	return (func(inter) < (self._threshold * k))	return (func(inter) < (self._threshold * k))


	class pyZSmallerUP1D(UnaryPredicate1D):	class pyZSmallerUP1D(UnaryPredicate1D):
	def __init__(self,z, integration=IntegrationType.MEAN):	def __init__(self, z, integration=IntegrationType.MEAN):
	UnaryPredicate1D.__init__(self)	UnaryPredicate1D.__init__(self)
	self._z = z	self._z = z
	self._integration = integration	self.func = GetProjectedZF1D(integration)

	def __call__(self, inter):	def __call__(self, inter):
	func = GetProjectedZF1D(self._integration)	return (self.func(inter) < self._z)
	return (func(inter) < self._z)


	class pyIsOccludedByUP1D(UnaryPredicate1D):	class pyIsOccludedByUP1D(UnaryPredicate1D):
Context not available.
	self._id = id	self._id = id

	def __call__(self, inter):	def __call__(self, inter):
	func = GetShapeF1D()	shapes = GetShapeF1D()(inter)
	shapes = func(inter)	if any(s.id == self._id for s in shapes):
	for s in shapes:	return False
	if(s.id == self._id):
	return False	# construct iterators
	it = inter.vertices_begin()	it = inter.vertices_begin()
	itlast = inter.vertices_end()	itlast = inter.vertices_end()
	itlast.decrement()	itlast.decrement()
	v = it.object
	vlast = itlast.object	vertex = next(it)
	tvertex = v.viewvertex	if type(vertex) is TVertex:
	if type(tvertex) is TVertex:	eit = vertex.edges_begin()
	#print("TVertex: [ ", tvertex.id.first, ",", tvertex.id.second," ]")	if any(ve.id == self._id for (ve, incoming) in eit):
		kjym3Unsubmitted Not Done Inline Actions Comparing the original and modified code, is `next(it)` the same as `it.object.viewvertex`? kjym3: Comparing the original and modified code, is `next(it)` the same as `it.object.viewvertex`?
		flokkievidsAuthorUnsubmitted Not Done Inline Actions Again, unable to test, executing this function enters an infinite loop printing "this steerable viewmap level does not exist" flokkievids: Again, unable to test, executing this function enters an infinite loop printing "this steerable…
	eit = tvertex.edges_begin()	return True
	while not eit.is_end:
	ve, incoming = eit.object	vertex = next(itlast)
	if ve.id == self._id:	if type(vertex) is TVertex:
	return True
	#print("-------", ve.id.first, "-", ve.id.second)
	eit.increment()
	tvertex = vlast.viewvertex
	if type(tvertex) is TVertex:
	#print("TVertex: [ ", tvertex.id.first, ",", tvertex.id.second," ]")
	eit = tvertex.edges_begin()	eit = tvertex.edges_begin()
	while not eit.is_end:	if any(ve.id == self._id for (ve, incoming) in eit):
		kjym3Unsubmitted Not Done Inline Actions Same question as in line 360. kjym3: Same question as in line 360.
	ve, incoming = eit.object	return True
	if ve.id == self._id:
	return True
	#print("-------", ve.id.first, "-", ve.id.second)
	eit.increment()
	return False	return False


Context not available.
	self._id = id	self._id = id

	def __call__(self, inter):	def __call__(self, inter):
	func = GetOccludersF1D()	occluders = GetOccludersF1D()(inter)
	occluders = func(inter)	return any(a.id == self._id for a in occluders)
	for a in occluders:
	if a.id == self._id:
	return True
	return False


	class pyIsOccludedByItselfUP1D(UnaryPredicate1D):	class pyIsOccludedByItselfUP1D(UnaryPredicate1D):
Context not available.
	def __call__(self, inter):	def __call__(self, inter):
	lst1 = self.__func1(inter)	lst1 = self.__func1(inter)
	lst2 = self.__func2(inter)	lst2 = self.__func2(inter)
	for vs1 in lst1:	return any(vs1.id == vs2.id for vs1 in lst1 for vs2 in lst2)
	for vs2 in lst2:
	if vs1.id == vs2.id:
	return True
	return False


	class pyIsOccludedByIdListUP1D(UnaryPredicate1D):	class pyIsOccludedByIdListUP1D(UnaryPredicate1D):
Context not available.
	self.__func1 = GetOccludersF1D()	self.__func1 = GetOccludersF1D()

	def __call__(self, inter):	def __call__(self, inter):
	lst1 = self.__func1(inter)	lst1 = self.__func1(inter.object)
	for vs1 in lst1:	return any(vs1.id == _id for vs1 in lst1 for _id in self._idlist)
	for _id in self._idlist:
	if vs1.id == _id:
	return True
	return False


	class pyShapeIdListUP1D(UnaryPredicate1D):	class pyShapeIdListUP1D(UnaryPredicate1D):
	def __init__(self,idlist):	def __init__(self,idlist):
	UnaryPredicate1D.__init__(self)	UnaryPredicate1D.__init__(self)
	self._idlist = idlist	self._funcs = tuple(ShapeUP1D(_id, 0) for _id in idlist)
	self._funcs = []
	for _id in idlist:
	self._funcs.append(ShapeUP1D(_id.first, _id.second))

	def __call__(self, inter):	def __call__(self, inter):
	for func in self._funcs:	return any(func(inter) for func in self._funcs)
	if func(inter) == 1:
	return True
	return False


	## deprecated	## deprecated
Context not available.
	self._id = _id	self._id = _id

	def __call__(self, inter):	def __call__(self, inter):
	func = GetShapeF1D()	shapes = GetShapeF1D()(inter)
	shapes = func(inter)	return any(a.id == self._id for a in shapes)
	for a in shapes:
	if a.id == self._id:
	return True
	return False


	class pyHighDensityAnisotropyUP1D(UnaryPredicate1D):	class pyHighDensityAnisotropyUP1D(UnaryPredicate1D):
Context not available.

	def __call__(self, inter):	def __call__(self, inter):
	gn = self._GetGradient(inter)	gn = self._GetGradient(inter)
	#print(gn)
	return (gn > self._threshold)	return (gn > self._threshold)


Context not available.
	it = inter.vertices_begin()	it = inter.vertices_begin()
	itlast = inter.vertices_end()	itlast = inter.vertices_end()
	itlast.decrement()	itlast.decrement()
	vlast = itlast.object	return (next(it).id == next(itlast).id)
	v = it.object
	#print(v.id.first, v.id.second)
	#print(vlast.id.first, vlast.id.second)
	if v.id == vlast.id:
	return True
	return False

	## Binary predicates for 1D elements (curves)	# -- Binary predicates for 1D elements (curves) -- #
	#############################################

	class AndBP1D(BinaryPredicate1D):	class AndBP1D(BinaryPredicate1D):
	def __init__(self, pred1, pred2):	def __init__(self, *predicates):
	BinaryPredicate1D.__init__(self)	BinaryPredicate1D.__init__(self)
	self.__pred1 = pred1	self._predicates = predicates
	self.__pred2 = pred2	if len(self.predicates) < 2:
		raise ValueError("Expected two or more UnaryPredicate0D")
		kjym3Unsubmitted Not Done Inline Actions Should be `if not self._predicates:`. kjym3: Should be `if not self._predicates:`.
		kjym3Unsubmitted Not Done Inline Actions "Expected two or more BinaryPredicate1D" kjym3: "Expected two or more BinaryPredicate1D"
	def __call__(self, inter1, inter2):
	return self.__pred1(inter1, inter2) and self.__pred2(inter1, inter2)

		def __call__(self, i1, i2):
		return all(pred(i1, i2) for pred in self._predicates)

	class OrBP1D(BinaryPredicate1D):	class OrBP1D(BinaryPredicate1D):
		kjym3Unsubmitted Not Done Inline Actions Same comment here as in AndUP1D. kjym3: Same comment here as in AndUP1D.
	def __init__(self, pred1, pred2):	def __init__(self, *predicates):
	BinaryPredicate1D.__init__(self)	BinaryPredicate1D.__init__(self)
	self.__pred1 = pred1	self._predicates = predicates
	self.__pred2 = pred2	if len(self.predicates) < 2:
		raise ValueError("Expected two or more UnaryPredicate0D")
		kjym3Unsubmitted Not Done Inline Actions Same as the comment in line 482. kjym3: Same as the comment in line 482.
		kjym3Unsubmitted Not Done Inline Actions "Expected two or more BinaryPredicate1D" kjym3: "Expected two or more BinaryPredicate1D"

	def __call__(self, inter1, inter2):	def __call__(self, i1, i2):
	return self.__pred1(inter1, inter2) or self.__pred2(inter1, inter2)	return any(pred(i1, i2) for pred in self._predicates)


		kjym3Unsubmitted Not Done Inline Actions Same comment here as in OrUP1D. kjym3: Same comment here as in OrUP1D.
	class NotBP1D(BinaryPredicate1D):	class NotBP1D(BinaryPredicate1D):
	def __init__(self, pred):	def __init__(self, predicate):
	BinaryPredicate1D.__init__(self)	BinaryPredicate1D.__init__(self)
	self.__pred = pred	self._predicate = predicate

	def __call__(self, inter1, inter2):	def __call__(self, i1, i2):
	return not self.__pred(inter1, inter2)	return (not self._precicate(i1, i2))


	class pyZBP1D(BinaryPredicate1D):	class pyZBP1D(BinaryPredicate1D):
	def __init__(self, iType=IntegrationType.MEAN):	def __init__(self, iType=IntegrationType.MEAN):
	BinaryPredicate1D.__init__(self)	BinaryPredicate1D.__init__(self)
	self._GetZ = GetZF1D(iType)	self.func = GetZF1D(iType)

	def __call__(self, i1, i2):	def __call__(self, i1, i2):
	return (self._GetZ(i1) > self._GetZ(i2))	return (self.func(i1) > self.func(i2))


	class pyZDiscontinuityBP1D(BinaryPredicate1D):	class pyZDiscontinuityBP1D(BinaryPredicate1D):
Context not available.
	class pySilhouetteFirstBP1D(BinaryPredicate1D):	class pySilhouetteFirstBP1D(BinaryPredicate1D):
	def __call__(self, inter1, inter2):	def __call__(self, inter1, inter2):
	bpred = SameShapeIdBP1D()	bpred = SameShapeIdBP1D()
	if (bpred(inter1, inter2) != 1):	if (not bpred(inter1, inter2)):
	return False	return False
	if (inter1.nature & Nature.SILHOUETTE):	if (inter1.nature & Nature.SILHOUETTE):
	return (inter2.nature & Nature.SILHOUETTE) != 0	return bool(inter2.nature & Nature.SILHOUETTE)
	return (inter1.nature == inter2.nature)	return (inter1.nature == inter2.nature)

		kjym3Unsubmitted Not Done Inline Actions This comment is not always true, since pyNatureBP1D is mostly meant to be used as an argument of an API function that takes a 1D binary predicate. kjym3: This comment is not always true, since pyNatureBP1D is mostly meant to be used as an argument…
		# you could just do this inline
	class pyNatureBP1D(BinaryPredicate1D):	class pyNatureBP1D(BinaryPredicate1D):
	def __call__(self, inter1, inter2):	def __call__(self, inter1, inter2):
	return (inter1.nature & inter2.nature)	return (inter1.nature & inter2.nature)
Context not available.
	self._GetGradient = pyViewMapGradientNormF1D(l, IntegrationType.MEAN)	self._GetGradient = pyViewMapGradientNormF1D(l, IntegrationType.MEAN)

	def __call__(self, i1,i2):	def __call__(self, i1,i2):
	#print("compare gradient")
	return (self._GetGradient(i1) > self._GetGradient(i2))	return (self._GetGradient(i1) > self._GetGradient(i2))


Context not available.
	random.seed(1)	random.seed(1)

	def __call__(self, inter1, inter2):	def __call__(self, inter1, inter2):
	r1 = random.uniform(0,1)	return (random.uniform(0,1) < random.uniform(0,1))
	r2 = random.uniform(0,1)
	return (r1<r2)
Context not available.