Initial addition of Python scripts

bond.py

@@ -0,0 +1,182 @@
+from workspaceStructure import WorkspaceStructure
+from slipnet import slipnet
+from workspace import workspace
+
+class Bond(WorkspaceStructure):
+	def __init__(self,source, destination, bondCategory, bondFacet, sourceDescriptor, destinationDescriptor):
+		WorkspaceStructure.__init__(self)
+		self.source = source
+		self.string = self.source.string
+		self.destination = destination
+		self.leftObject = self.source
+		self.rightObject = self.destination
+		self.directionCategory = slipnet.right
+		if self.source.leftStringPosition > self.destination.rightStringPosition:
+			self.leftObject = self.destination
+			self.rightObject = self.source
+			self.directionCategory = slipnet.left
+		self.facet = bondFacet
+		self.sourceDescriptor = sourceDescriptor
+		self.destinationDescriptor = destinationDescriptor
+		self.category = bondCategory
+
+		self.destinationIsOnRight = self.destination == self.rightObject
+		self.bidirectional = self.sourceDescriptor == self.destinationDescriptor
+		if self.bidirectional:
+			self.directionCategory = None
+
+	def flippedVersion(self):
+		"""
+
+		"""
+		return Bond(
+				self.destination, self.get_source(), self.category.getRelatedNode(slipnet.opposite),
+				self.facet, self.destinationDescriptor, self.sourceDescriptor
+		)
+
+	def __repr__(self):
+		return '<Bond: %s>' % self.__str__()
+
+	def __str__(self):
+		return '%s bond between %s and %s' % ( self.category.name, self.leftObject, self.rightObject)
+
+	def buildBond(self):
+		workspace.structures += [ self ]
+		self.string.bonds += [ self ]
+		self.category.buffer = 100.0
+		if self.directionCategory:
+				self.directionCategory.buffer = 100.0
+		self.leftObject.rightBond = self
+		self.rightObject.leftBond = self
+		self.leftObject.bonds += [ self ]
+		self.rightObject.bonds += [ self ]
+
+	def break_the_structure(self):
+		self.breakBond()
+
+	def breakBond(self):
+		if self in workspace.structures:
+			workspace.structures.remove(self)
+		if self in self.string.bonds:
+			self.string.bonds.remove(self)
+		self.leftObject.rightBond = None
+		self.rightObject.leftBond = None
+		if self in self.leftObject.bonds:
+			self.leftObject.bonds.remove(self)
+		if self in self.rightObject.bonds:
+			self.rightObject.bonds.remove(self)
+
+	def getIncompatibleCorrespondences(self):
+		# returns a list of correspondences that are incompatible with
+		# self bond
+		incompatibles = []
+		if self.leftObject.leftmost and self.leftObject.correspondence:
+			correspondence = self.leftObject.correspondence
+			if self.string == workspace.initial:
+				objekt = self.leftObject.correspondence.objectFromTarget
+			else:
+				objekt = self.leftObject.correspondence.objectFromInitial
+			if objekt.leftmost and objekt.rightBond:
+				if objekt.rightBond.directionCategory and objekt.rightBond.directionCategory != self.directionCategory:
+					incompatibles += [ correspondence ]
+		if self.rightObject.rightmost and self.rightObject.correspondence:
+			correspondence = self.rightObject.correspondence
+			if self.string == workspace.initial:
+				objekt = self.rightObject.correspondence.objectFromTarget
+			else:
+				objekt = self.rightObject.correspondence.objectFromInitial
+			if objekt.rightmost and objekt.leftBond:
+				if objekt.leftBond.directionCategory and objekt.leftBond.directionCategory != self.directionCategory:
+					incompatibles += [ correspondence ]
+		return incompatibles
+
+	def updateInternalStrength(self):
+		# bonds between objects of same type(ie. letter or group) are
+		# stronger than bonds between different types
+		sourceGap = self.get_source().leftStringPosition != self.get_source().rightStringPosition
+		destinationGap = self.destination.leftStringPosition != self.destination.rightStringPosition
+		if sourceGap == destinationGap:
+			memberCompatibility = 1.0
+		else:
+			memberCompatibility = 0.7
+		# letter category bonds are stronger
+		if self.facet == slipnet.letterCategory:
+			facetFactor = 1.0
+		else:
+			facetFactor = 0.7
+		strength = min(100.0,memberCompatibility * facetFactor * self.category.bondDegreeOfAssociation())
+		self.internalStrength = strength
+
+	def updateExternalStrength(self):
+		self.externalStrength = 0.0
+		supporters = self.numberOfLocalSupportingBonds()
+		if supporters > 0.0:
+			density = self.localDensity() / 100.0
+			density = density ** 0.5 * 100.0
+			supportFactor = 0.6 ** (1.0 / supporters ** 3)
+			supportFactor = max(1.0,supportFactor)
+			strength = supportFactor * density
+			self.externalStrength = strength
+
+	def numberOfLocalSupportingBonds(self):
+		return len([ b for b in self.string.bonds if b.string == self.get_source().string and
+			self.leftObject.letterDistance(b.leftObject) != 0 and
+			self.rightObject.letterDistance(b.rightObject) != 0 and
+			self.category == b.category and
+			self.directionCategory == b.directionCategory ])
+
+	def sameCategories(self,other):
+		return self.category == other.category and self.directionCategory == other.directionCategory
+
+	def myEnds(self,object1,object2):
+		if self.get_source() == object1 and self.destination == object2:
+			return True
+		return self.get_source() == object2 and self.destination == object1
+
+	def localDensity(self):
+		# returns a rough measure of the density in the string
+		# of the same bond-category and the direction-category of
+		# the given bond
+		slotSum = supportSum = 0.0
+		for object1 in workspace.objects:
+			if object1.string == self.string:
+				for object2 in workspace.objects:
+					if object1.beside(object2):
+						slotSum += 1.0
+						for bond in self.string.bonds:
+							if bond != self and self.sameCategories(bond) and self.myEnds(object1,object2):
+									supportSum += 1.0
+		if slotSum == 0.0:
+				return 0.0
+		return 100.0 * supportSum / slotSum
+
+	def sameNeighbours(self,other):
+		if self.leftObject == other.leftObject:
+			return True
+		return self.rightObject == other.rightObject
+
+	def getIncompatibleBonds(self):
+		return [ b for b in self.string.bonds if self.sameNeighbours(b) ]
+
+	def get_source(self):
+		return self.source
+
+	def set_source(self, value):
+		self.source = value
+
+def possibleGroupBonds(bondCategory, directionCategory, bondFacet, bonds):
+	result = []
+	for bond in bonds:
+		if bond.category == bondCategory and bond.directionCategory == directionCategory:
+			result += [ bond ]
+		else:
+			# a modified bond might be made
+			if bondCategory == slipnet.sameness:
+				return None # a different bond cannot be made here
+			if bond.category == bondCategory or bond.directionCategory == directionCategory:
+				return None # a different bond cannot be made here
+			if bond.category == slipnet.sameness:
+				return None
+			bond = Bond(bond.destination, bond.get_source(), bondCategory, bondFacet, bond.destinationDescriptor, bond.sourceDescriptor)
+			result += [ bond ]
+	return result