def test():
graph = MethodGraph()
graph.add_variable('a', 1)
graph.add_variable('b', 2)
mv_x = MultiVariable('x')
graph.add_variable(mv_x)
graph.add_method(SumProdMethod('a', 'b', mv_x))
graph.add_variable('p', 3)
graph.add_variable('q', 4)
mv_y = MultiVariable('y')
graph.add_variable(mv_y)
graph.add_method(SumProdMethod('p', 'q', mv_y))
mv_z = MultiVariable('z')
graph.add_variable(mv_z)
graph.add_method(SumProdMethod(mv_x, mv_y, mv_z))
print graph.get(mv_z)
graph.set('a', 100)
print graph.get(mv_z)
def test():
graph = MethodGraph()
graph.add_variable('a', 1)
graph.add_variable('b', 2)
mv_x = MultiVariable('x')
graph.add_variable(mv_x)
graph.add_method(SumProdMethod('a','b', mv_x))
graph.add_variable('p', 3)
graph.add_variable('q', 4)
mv_y = MultiVariable('y')
graph.add_variable(mv_y)
graph.add_method(SumProdMethod('p','q', mv_y))
mv_z = MultiVariable('z')
graph.add_variable(mv_z)
graph.add_method(SumProdMethod(mv_x,mv_y,mv_z))
print graph.get(mv_z)
graph.set('a', 100)
print graph.get(mv_z)
class ClusterSolver(Notifier):
"""
Finds a generic solution for problems formulated by Clusters.
Cluster are added and removed using the add and remove methods.
After adding each Cluster, the solver tries to merge it with
others, resulting in new Clusters.
The generic solution is a directed acyclic graph of Clusters and Methods.
Particilar problems and solutions are represented by a Configuration
for each cluster.
For each Cluster a set of Configurations can be set using the
set method. Configurations are propagated via Methods and can
be retrieved with the get method.
"""
# ------- PUBLIC METHODS --------
def __init__(self, methodclasses):
"""Create a new solver, using the given subclasses of ClusterMethod."""
# init superclasses
Notifier.__init__(self)
# store arguments
self._methodclasses = methodclasses
self._pattern_methods = filter(lambda m: hasattr(m,"patterngraph"),self._methodclasses)
self._handcoded_methods = filter(lambda m: hasattr(m,"handcoded_match"),self._methodclasses)
self._incremental_methods = filter(lambda m: hasattr(m,"incremental_matcher"),self._methodclasses)
# init instance vars
self._graph = Graph()
#self._graph.add_vertex("_root")
# self._graph.add_vertex("_toplevel")
self._graph.add_vertex("_variables")
self._graph.add_vertex("_clusters")
self._graph.add_vertex("_methods")
self._new = []
self._mg = MethodGraph()
# add prototype_selection boolean var to method graph
self._prototype_selection_var = "_prototype_selection_enabled"
self._mg.add_variable(self._prototype_selection_var)
self._mg.set(self._prototype_selection_var, True)
# store map of selection_constraints to SelectionMethod (or None)
self._selection_method = {}
# store root cluster (will be assigned when first cluster added)
self._rootcluster = None
# an incrementally updated toplevel set
self._toplevel = MutableSet()
# incrementally updated set of applicable methods
self._incremental_matchers = map(lambda method: method.incremental_matcher(self), self._incremental_methods)
#print "incremental matchers:",self._incremental_matchers
self._applicable_methods = Union(*self._incremental_matchers)
# ------- methods for setting up constraint problems ------------
def add(self, cluster):
"""Add a cluster"""
diag_print("add_cluster "+str(cluster), "clsolver")
self._add_cluster(cluster)
self._process_new()
def remove(self, cluster):
"""Remove a cluster.
All dependend objects are also removed.
"""
self._remove(cluster)
self._process_new()
def set(self, cluster, configurations):
"""Associate a list of configurations with a cluster"""
self._mg.set(cluster, configurations)
def get(self, cluster):
"""Return a set of configurations associated with a cluster"""
return self._mg.get(cluster)
def set_root(self, cluster):
"""Set root cluster, used for positionig and orienting the solutions"""
diag_print("set root "+str(self._rootcluster), "clsolver")
if self._rootcluster != None:
oldrootvar = rootname(self._rootcluster)
self._mg.set(oldrootvar, False)
newrootvar = rootname(cluster)
self._mg.set(newrootvar, True)
self._rootcluster = cluster
def get_root(self):
"""returns current root cluster or None"""
return self._rootcluster
def set_prototype_selection(self, enabled):
"""Enable or disable prototype-based solution selection"""
self._mg.set(self._prototype_selection_var, enabled)
def add_selection_constraint(self, con):
"""Add a SelectionConstraint to filter solutions"""
if con not in self._selection_method:
selector = self._find_selection_method(con)
if selector != None:
selector.add_constraint(con)
self._selection_method[con] = selector
self._mg.execute(selector)
#self._selection_method[con] = None # this line wrong?
self._selection_method[con] = selector # this line better?
def rem_selection_constraint(self, con):
"""Remove a SelectionConstraint"""
if con in self._selection_method:
selector = self._selection_method[con]
if selector != None:
selector.rem_constraint(con)
self._mg.execute(selector)
del self._selection_method[con]
# ------- methods for inspecting the state of the solver ------------
def variables(self):
"""get list of variables"""
return self._graph.outgoing_vertices("_variables")
def clusters(self):
"""get list of clusters"""
return self._graph.outgoing_vertices("_clusters")
def methods(self):
"""get list of methods"""
return self._graph.outgoing_vertices("_methods")
def top_level(self):
"""return IncrementalSet of top-level clusters"""
return self._toplevel
# return self._graph.outgoing_vertices("_toplevel")
def is_top_level(self, object):
"""Returns True iff given cluster is a top-level cluster"""
#return self._graph.has_edge("_toplevel",object)
return object in self._toplevel
def find_dependend(self, object):
"""Return a list of objects that depend on given object directly."""
l = self._graph.outgoing_vertices(object)
return filter(lambda x: self._graph.get(object,x) == "dependency", l)
def find_depends(self, object):
"""Return a list of objects that the given object depends on directly"""
l = self._graph.ingoing_vertices(object)
return filter(lambda x: self._graph.get(x,object) == "dependency", l)
def contains(self, obj):
return self._graph.has_vertex(obj)
# ------------ INTERNALLY USED METHODS --------
# --- dependencies and groups
def _add_dependency(self, on, dependend):
"""Add a dependence for second object on first object"""
self._graph.add_edge(on, dependend, "dependency")
def _add_to_group(self, group, object):
"""Add object to group"""
self._graph.add_edge(group, object, "contains")
def _add_needed_by(self, needed, by):
"""Add relation 'needed' object is needed 'by'"""
self._graph.add_edge(needed, by, "needed_by")
def _objects_that_need(self, needed):
"""Return objects needed by given object"""
l = self._graph.outgoing_vertices(needed)
return filter(lambda x: self._graph.get(needed,x) == "needed_by", l)
def _objects_needed_by(self, needer):
"""Return objects needed by given object"""
l = self._graph.ingoing_vertices(needer)
return filter(lambda x: self._graph.get(x,needer) == "needed_by", l)
def _add_top_level(self, cluster):
# self._graph.add_edge("_toplevel",cluster)
self._new.append(cluster)
self._toplevel.add(cluster)
def _rem_top_level(self, object):
# self._graph.rem_edge("_toplevel",object)
if object in self._new:
self._new.remove(object)
self._toplevel.remove(object)
def _find_descendend(self,v):
"""find all descendend objects of v (i.e.. directly or indirectly dependend)"""
front = [v]
result = {}
while len(front) > 0:
x = front.pop()
if x not in result:
result[x] = 1
front += self.find_dependend(x)
del result[v]
return list(result)
# -- add object types
def _add_variable(self, var):
if not self._graph.has_vertex(var):
diag_print("_add_variable "+str(var), "clsolver")
self._add_to_group("_variables", var)
def _add_cluster(self, newcluster):
diag_print("_add_cluster "+str(newcluster),"clsolver")
# check if not already exists
if self._graph.has_vertex(newcluster):
raise StandardError, "cluster %s already in clsolver"%(str(newcluster))
# update graph
self._add_to_group("_clusters", newcluster)
for var in newcluster.vars:
self._add_variable(var)
self._add_dependency(var, newcluster)
# add to top level
self._add_top_level(newcluster)
# add to methodgraph
self._mg.add_variable(newcluster)
# add root-variable if needed with default value False
root = rootname(newcluster)
if not self._mg.contains(root):
self._mg.add_variable(root, False)
self._mg.set(root, False)
# add root-variable to dependency graph
self._add_dependency(newcluster, root)
# if there is no root cluster, this one will be it
if self.get_root() == None:
self.set_root(newcluster)
# notify listeners
self.send_notify(("add", newcluster))
def _add_method(self, method):
diag_print("new "+str(method),"clsolver")
self._add_to_group("_methods", method)
for obj in method.inputs():
self._add_dependency(obj, method)
for obj in method.outputs():
self._add_dependency(method, obj)
self._add_dependency(obj, method)
self._mg.add_method(method)
self.send_notify(("add", method))
# ----- solution selection
def _add_prototype_selector(self, merge):
incluster = merge.outputs()[0]
constraints = merge.prototype_constraints()
vars = set()
for con in constraints:
vars.update(con.variables())
selclusters = []
for var in vars:
clusters = self._graph.outgoing_vertices(var)
clusters = filter(lambda c: isinstance(c, Rigid), clusters)
clusters = filter(lambda c: len(c.vars) == 1, clusters)
if len(clusters) < 1:
raise StandardError, "no prototype cluster for variable "+str(var)
elif len(clusters) > 1:
raise StandardError, "more than one candidate prototype cluster for variable "+str(var)
selclusters.append(clusters[0])
outcluster = incluster.copy()
selector = PrototypeMethod(incluster, selclusters, outcluster, constraints, self._prototype_selection_var)
self._add_cluster(outcluster)
self._add_method(selector)
self._rem_top_level(incluster)
return outcluster
def _add_solution_selector(self, incluster):
outcluster = incluster.copy()
selector = SelectionMethod(incluster, outcluster)
constraints = self._find_selection_constraints(incluster)
for con in constraints:
selector.add_constraint(con)
self._selection_method[con] = selector
self._add_cluster(outcluster)
self._add_method(selector)
self._rem_top_level(incluster)
return selector
def _find_selection_method(self, con):
# find clusters containing all constraints vars
candidates = None
for var in con.variables():
# find clusters
clusters = set(self.find_dependend(var))
if candidates == None:
candidates = clusters
else:
candidates = candidates.intersection(clusters)
# get selection methods of clusters
methods = []
for cluster in candidates:
methods += filter(lambda c: isinstance(c,SelectionMethod), self.find_depends(cluster))
# get selection method with smallest cluster
if len(methods)>0:
method = min(methods, key=lambda m: len(m.inputs()[0].vars))
return method
else:
return None
##slow implementation, better would be to find method via clustering information in graph
#convars = set(con.variables())
#selmethods = filter(lambda x: isinstance(x,SelectionMethod), self.methods())
#for method in selmethods:
# incluster = method.inputs()[0]
# clvars = set(incluster.vars)
# if clvars.intersection(convars) == convars:
# return method
#return None
def _find_selection_constraints(self, incluster):
applicable = []
for con in self._selection_method:
selector = self._selection_method[con]
if selector == None:
convars = set(con.variables())
clvars = set(incluster.vars)
if convars.intersection(clvars) == convars:
applicable.append(con)
return applicable
# --------------
# isearch methods
# --------------
def _process_new(self):
# try incremental matchers and old style matching alternatingly
non_redundant_methods = filter(lambda m: not self._is_redundant_method(m), self._applicable_methods)
while len(non_redundant_methods) > 0 or len(self._new) > 0:
# check incremental matches
if len(non_redundant_methods) > 0:
method = iter(non_redundant_methods).next()
#print "applicable methods:", map(str, self._applicable_methods)
diag_print("incremental search found:"+str(method),"clsolver._process_new")
self._add_method_complete(method)
else:
newobject = self._new.pop()
diag_print("search from "+str(newobject), "clsolver")
succes = self._search(newobject)
if succes and self.is_top_level(newobject):
# maybe more rules applicable.... push back on stack
self._new.append(newobject)
#endif
# endif
non_redundant_methods = filter(lambda m: not self._is_redundant_method(m), self._applicable_methods)
# endwhile
#end def
def _search(self, newcluster):
diag_print("search from:"+str(newcluster),"clsolver3D")
# find all toplevel clusters connected to newcluster
# via one or more variables
connected = set()
for var in newcluster.vars:
dependend = self.find_dependend(var)
dependend = filter(lambda x: self.is_top_level(x), dependend)
connected.update(dependend)
diag_print("search: connected clusters="+str(connected),"clsolver3D")
# first try handcoded matching
for methodclass in self._handcoded_methods:
diag_print("trying handcoded match for "+str(methodclass), "clsolver3D")
matches = methodclass.handcoded_match(self, newcluster, connected)
if self._try_matches(methodclass, matches):
return True
# if incremental matching failed, try full pattern matching
if self._try_methods(connected):
return True
return False
def _try_methods(self, nlet):
"""finds a possible rewrite rule applications on given set of clusters, applies it
and returns True iff successfull
"""
refgraph = reference2graph(nlet)
for methodclass in self._pattern_methods:
diag_print("trying generic pattern matching for "+str(methodclass), "clsolver3D")
matches = gmatch(methodclass.patterngraph, refgraph)
if self._try_matches(methodclass,matches):
return True
# end for match
# end for method
return False
def _try_matches(self, methodclass, matches):
# print "method="+str(methodclass),"number of matches = "+str(len(matches))
for s in matches:
diag_print("try match: "+str(s),"clsolver3D")
method = apply(methodclass, [s])
succes = self._add_method_complete(method)
if succes:
#raw_input()
#print "press key"
return True
else: # WARING: fast bailout, may be incoplete!
return False
# end for match
return False
def _is_information_increasing(self, merge):
# check that the method is information increasing (infinc)
output = merge.outputs()[0]
infinc = True
connected = set()
for var in output.vars:
dependend = self.find_dependend(var)
dependend = filter(lambda x: self.is_top_level(x), dependend)
connected.update(dependend)
# NOTE 07-11-2007 (while writing the paper): this implementation of information increasing may not be correct. We may need to check that the total sum of the information in the overlapping clusters is equal to the information in the output.
for cluster in connected:
if num_constraints(cluster.intersection(output)) >= num_constraints(output):
infinc = False
break
diag_print("information increasing:"+str(infinc),"clsolver")
return infinc
def _is_cluster_reducing(self, merge):
# check if method reduces number of clusters (reduc)
output = merge.outputs()[0]
nremove = 0
for cluster in merge.input_clusters():
if num_constraints(cluster.intersection(output)) >= num_constraints(cluster):
# will be removed from toplevel
nremove += 1
# exeption if method sets noremove flag
if hasattr(merge,"noremove") and merge.noremove == True:
nremove = 0
reduc = (nremove > 1)
diag_print("reduce # clusters:"+str(reduc),"clsolver")
return reduc
def _is_redundant_method(self, merge):
# check if the method is redundant (not information increasing and not reducing number of clusters)
infinc = self._is_information_increasing(merge)
reduc = self._is_cluster_reducing(merge)
if not infinc and not reduc:
diag_print("method is redundant","clsolver")
return True
else:
diag_print("method is not redundant","clsolver")
return False
def _add_method_complete(self, merge):
diag_print("add_method_complete "+str(merge), "clsolver")
# do not add if method is redundant
if self._is_redundant_method(merge):
return False
output = merge.outputs()[0]
# check consistency and local/global overconstrained
consistent = True
local_oc = False
for i1 in range(0, len(merge.input_clusters())):
for i2 in range(i1+1, len(merge.input_clusters())):
c1 = merge.input_clusters()[i1]
c2 = merge.input_clusters()[i2]
if num_constraints(c1.intersection(c2)) != 0:
local_oc = True
consistent = consistent and self._is_consistent_pair(c1, c2)
merge.consistent = consistent
merge.overconstrained = local_oc
# global overconstrained? (store in output cluster)
overconstrained = not consistent
for cluster in merge.input_clusters():
overconstrained = overconstrained or cluster.overconstrained
output.overconstrained = overconstrained
# determine infinc before adding (used later)
infinc = self._is_information_increasing(merge)
# add to graph
self._add_cluster(output)
self._add_method(merge)
# remove input clusters from top_level
merge.restore_toplevel = [] # make restore list in method
for cluster in merge.input_clusters():
# do not remove rigids from toplevel if method does not consider root
if isinstance(cluster, Rigid):
if hasattr(merge,"noremove") and merge.noremove == True:
diag_print("block top-level", "clsolver")
break
# remove input clusters when all its constraints are in output cluster
if num_constraints(cluster.intersection(output)) >= num_constraints(cluster):
diag_print("remove from top-level: "+str(cluster),"clsolver")
self._rem_top_level(cluster)
merge.restore_toplevel.append(cluster)
else:
diag_print("keep top-level: "+str(cluster),"clsolver")
# add method to determine root-variable
if hasattr(merge,"noremove") and merge.noremove == True:
self._add_root_false(merge.outputs()[0])
else:
self._add_root_method(merge.input_clusters(),merge.outputs()[0])
# add solution selection methods, only if information increasing
if infinc:
output2 = self._add_prototype_selector(merge)
output3 = self._add_solution_selector(output2)
# success
return True
def _add_root_method(self,inclusters,outcluster):
inroots = []
for cluster in inclusters:
inroots.append(rootname(cluster))
outroot = rootname(outcluster)
method = OrMethod(inroots, outroot)
# add method
self._add_method(method)
# make sure its deleted when cluster is deleted
self._add_dependency(outcluster, method)
def _add_root_false(self,outcluster):
outroot = rootname(outcluster)
method = SetMethod(outroot, False)
# add method
self._add_method(method)
# make sure its deleted when cluster is deleted
self._add_dependency(outcluster, method)
# -- removing objects
def _remove(self, object):
# find all indirectly dependend objects
todelete = [object]+self._find_descendend(object)
torestore = set()
# remove all objects
for item in todelete:
# if merge removed items from toplevel then add them back to top level
if hasattr(item, "restore_toplevel"):
for cluster in item.restore_toplevel:
torestore.add(cluster)
# delete it from graph
diag_print("deleting "+str(item),"clsolver.remove")
self._graph.rem_vertex(item)
# remove from _new list
if item in self._new:
self._new.remove(item)
# remove from incremental top_level
self._toplevel.remove(item)
# remove from methodgraph
if isinstance(item, Method):
# note: method may have been removed because variable removed
try:
self._mg.rem_method(item)
except:
pass
# restore SelectionConstraints
if isinstance(item, SelectionMethod):
for con in item.iter_constraints():
self._selection_method[con] = None
if isinstance(item, MultiVariable):
self._mg.rem_variable(item)
# remove variables with no dependent clusters
if isinstance(item, Cluster):
for var in item.vars:
if len(self.find_dependend(var)) == 0:
self._graph.rem_vertex(var)
# notify listeners
self.send_notify(("remove", item))
# restore toplevel (also added to _new)
for cluster in torestore:
if self._graph.has_vertex(cluster):
self._add_top_level(cluster)
##def _contains_root(self, input_cluster):
## """returns True iff input_cluster is root cluster or was determined by
## merging with the root cluster."""
##
## # start from root cluster. Follow merges upwards until:
## # - input cluster found -> True
## # - no more merges -> False
##
## if len(self._graph.outgoing_vertices("_root")) > 1:
## raise StandardError, "more than one root cluster"
## if len(self._graph.outgoing_vertices("_root")) == 1:
## cluster = self._graph.outgoing_vertices("_root")[0]
## else:
## cluster = None
## while (cluster != None):
## if cluster is input_cluster:
## return True
## fr = self._graph.outgoing_vertices(cluster)
## me = filter(lambda x: isinstance(x, Merge), fr)
## me = filter(lambda x: cluster in x.outputs(), me)
## if len(me) > 1:
## raise StandardError, "root cluster merged more than once"
## elif len(me) == 0:
## cluster = None
## elif len(me[0].outputs()) != 1:
## raise StandardError, "a merge with number of outputs != 1"
## else:
## cluster = me[0].outputs()[0]
## #while
## return False
#def
# ---- consistency
def _is_consistent_pair(self, object1, object2):
diag_print("in is_consistent_pair "+str(object1)+" "+str(object2),"clsolver")
oc = over_constraints(object1, object2)
diag_print("over_constraints: "+str(map(str,oc)),"clsolver")
consistent = True
for con in oc:
consistent = consistent and self._consistent_overconstraint_in_pair(con, object1, object2)
diag_print("global consistent? "+str(consistent),"clsolver")
return consistent
def _consistent_overconstraint_in_pair(self, overconstraint, object1, object2):
diag_print("consistent "+str(overconstraint)+" in "+str(object1)+" and "+str(object2)+" ?", "clsolver")
# get sources for constraint in given clusters
s1 = self._source_constraint_in_cluster(overconstraint, object1)
s2 = self._source_constraint_in_cluster(overconstraint, object2)
if s1 == None:
consistent = False
elif s2 == None:
consistent = False
elif s1 == s2:
consistent = True
else:
if self._is_atomic(s1) and not self._is_atomic(s2):
consistent = False
elif self._is_atomic(s2) and not self._is_atomic(s1):
consistent = False
else:
consistent = True
#c1to2 = constraits_from_s1_in_s2(s1, s2)
#if solve(c1to2) contains overconstraint then consistent
#c2to1 = constraits_from_s1_in_s2(s2, s1)
#if solve(c2to1) contains overconstraint then consistent
#raise StandardError, "not yet implemented"
diag_print("consistent? "+str(consistent), "clsolver")
return consistent
def _source_constraint_in_cluster(self, constraint, cluster):
if not self._contains_constraint(cluster, constraint):
raise StandardError, "constraint not in cluster"
elif self._is_atomic(cluster):
return cluster
else:
method = self._determining_method(cluster)
inputs = method.inputs()
down = filter(lambda x: self._contains_constraint(x, constraint), inputs)
if len(down) == 0:
return cluster
elif len(down) > 1:
if method.consistent == True:
return self._source_constraint_in_cluster(constraint, down[0])
else:
diag_print("Warning: source is inconsistent","clsolver")
return None
else:
return self._source_constraint_in_cluster(constraint, down[0])
def _is_atomic(self, object):
method = self._determining_method(object)
if method == None:
return True
#elif isinstance(method, Distance2Rigid) or isinstance(method, Angle2Hog):
# return True
else:
return False
def _determining_method(self, object):
depends = self.find_depends(object)
methods = filter(lambda x: isinstance(x, Method), depends)
if len(methods) == 0:
return None
elif len(methods) > 1:
raise "object determined by more than one method"
else:
return methods[0]
def _contains_constraint(self, object, constraint):
if isinstance(constraint, Distance):
return self._contains_distance(object, constraint)
elif isinstance(constraint, Angle):
return self._contains_angle(object, constraint)
else:
raise StandardError, "unexpected case"
def _contains_distance(self,object, distance):
if isinstance(object, Rigid):
return (distance.vars[0] in object.vars and distance.vars[1] in object.vars)
elif isinstance(object, Distance):
return (distance.vars[0] in object.vars and distance.vars[1] in object.vars)
else:
return False
def _contains_angle(self, object, angle):
if isinstance(object, Rigid) or isinstance(object, Balloon):
return (angle.vars[0] in object.vars
and angle.vars[1] in object.vars
and angle.vars[2] in object.vars)
elif isinstance(object, Hedgehog):
return (angle.vars[1] == object.cvar and
angle.vars[0] in object.xvars and
angle.vars[2] in object.xvars)
elif isinstance(object, Angle):
return (angle.vars[1] == object.vars[1] and
angle.vars[0] in object.vars and
angle.vars[2] in object.vars)
else:
return False
# --------- special methods ------
def __str__(self):
s = ""
s += "Clusters:\n"
for x in self.clusters():
s += str(x) + "\n"
s += "Methods:\n"
for x in self.methods():
s += str(x) + "\n"
return s
class ClusterSolver(Notifier):
"""Constraints are Clusers: Rigids, Hedgehogs and Balloons.
After adding each cluster, the solver tries to merge
clusters, adding new clusters and methods between clusters.
"""
# ------- PUBLIC METHODS --------
def __init__(self, dimension):
"""Create a new empty solver"""
Notifier.__init__(self)
self.dimension = dimension
self._graph = Graph()
self._graph.add_vertex("_root")
self._graph.add_vertex("_toplevel")
self._graph.add_vertex("_variables")
self._graph.add_vertex("_distances")
self._graph.add_vertex("_angles")
self._graph.add_vertex("_rigids")
self._graph.add_vertex("_hedgehogs")
self._graph.add_vertex("_balloons")
self._graph.add_vertex("_methods")
# queue of new objects to process
self._new = []
# methodgraph
self._mg = MethodGraph()
def variables(self):
"""get list of variables"""
return self._graph.outgoing_vertices("_variables")
def distances(self):
"""get list of distances"""
return self._graph.outgoing_vertices("_distances")
def angles(self):
"""get list of angles"""
return self._graph.outgoing_vertices("_angles")
def rigids(self):
"""get list of rigids"""
return self._graph.outgoing_vertices("_rigids")
def hedgehogs(self):
"""get list of hedgehogs"""
return self._graph.outgoing_vertices("_hedgehogs")
def balloons(self):
"""get list of balloons"""
return self._graph.outgoing_vertices("_balloons")
def methods(self):
"""get list of methods"""
return self._graph.outgoing_vertices("_methods")
def top_level(self):
"""get top-level objects"""
return self._graph.outgoing_vertices("_toplevel")
def is_top_level(self, object):
return self._graph.has_edge("_toplevel", object)
def add(self, cluster):
"""Add a cluster.
arguments:
cluster: A Rigid
"""
diag_print("add_cluster " + str(cluster), "clsolver")
self._add_cluster(cluster)
self._process_new()
def remove(self, cluster):
"""Remove a cluster.
All dependend objects are also removed.
"""
self._remove(cluster)
self._process_new()
def set(self, cluster, configurations):
"""Associate a list of configurations with a cluster"""
self._mg.set(cluster, configurations)
def get(self, cluster):
"""Return a set of configurations associated with a cluster"""
return self._mg.get(cluster)
def set_root(self, rigid):
"""Make given rigid cluster the root cluster
arguments:
cluster: A Rigid
"""
self._graph.rem_vertex("_root")
self._graph.add_edge("_root", rigid)
def find_dependend(self, object):
"""Return a list of objects that depend on given object directly."""
l = self._graph.outgoing_vertices(object)
return filter(lambda x: self._graph.get(object, x) == "dependency", l)
def find_depends(self, object):
"""Return a list of objects that the given object depends on directly"""
l = self._graph.ingoing_vertices(object)
return filter(lambda x: self._graph.get(x, object) == "dependency", l)
def contains(self, obj):
return self._graph.has_vertex(obj)
# ------------ INTERNALLY USED METHODS --------
# -- general house hold
def _add_dependency(self, on, dependend):
"""Add a dependence for second object on first object"""
self._graph.add_edge(on, dependend, "dependency")
def _add_to_group(self, group, object):
"""Add object to group"""
self._graph.add_edge(group, object, "contains")
def _add_needed_by(self, needed, by):
"""Add relation 'needed' object is needed 'by'"""
self._graph.add_edge(needed, by, "needed_by")
def _objects_that_need(self, needed):
"""Return objects needed by given object"""
l = self._graph.outgoing_vertices(needed)
return filter(lambda x: self._graph.get(needed, x) == "needed_by", l)
def _objects_needed_by(self, needer):
"""Return objects needed by given object"""
l = self._graph.ingoing_vertices(needer)
return filter(lambda x: self._graph.get(x, needer) == "needed_by", l)
def _add_top_level(self, object):
self._graph.add_edge("_toplevel", object)
self._new.append(object)
def _rem_top_level(self, object):
self._graph.rem_edge("_toplevel", object)
if object in self._new:
self._new.remove(object)
def _remove(self, object):
# find all indirectly dependend objects
todelete = [object] + self._find_descendend(object)
torestore = Set()
# remove all objects
for item in todelete:
# if merge removed items from toplevel then add them back to top level
if hasattr(item, "restore_toplevel"):
for cluster in item.restore_toplevel:
torestore.add(cluster)
# delete it from graph
diag_print("deleting " + str(item), "clsolver.remove")
self._graph.rem_vertex(item)
# remove from _new list
if item in self._new:
self._new.remove(item)
# remove from methodgraph
if isinstance(item, Method):
# note: method may have been removed because variable removed
try:
self._mg.rem_method(item)
except:
pass
elif isinstance(item, MultiVariable):
self._mg.rem_variable(item)
# notify listeners
self.send_notify(("remove", item))
# restore toplevel (also added to _new)
for cluster in torestore:
if self._graph.has_vertex(cluster):
self._add_top_level(cluster)
# debug
# print "after remove, drplan:"
# print self
# print "after remove, toplevel:"
# print self.top_level()
# re-solve
self._process_new()
def _find_descendend(self, v):
"""find all descendend objects of v (dirdctly or indirectly dependend"""
front = [v]
result = {}
while len(front) > 0:
x = front.pop()
if x not in result:
result[x] = 1
front += self.find_dependend(x)
del result[v]
return list(result)
# -- add object types
def _add_variable(self, var):
"""Add a variable if not already in system
arguments:
var: any hashable object
"""
if not self._graph.has_vertex(var):
diag_print("_add_variable " + str(var), "clsolver")
self._add_to_group("_variables", var)
def _add_cluster(self, cluster):
if isinstance(cluster, Rigid):
self._add_rigid(cluster)
elif isinstance(cluster, Hedgehog):
self._add_hog(cluster)
elif isinstance(cluster, Balloon):
self._add_balloon(cluster)
else:
raise StandardError, "unsupported type", type(cluster)
def _add_rigid(self, newcluster):
"""add a rigid cluster if not already in system"""
diag_print("_add_rigid " + str(newcluster), "clsolver")
# check if not already exists
if self._graph.has_vertex(newcluster):
raise StandardError, "rigid already in clsolver"
# update graph
self._add_to_group("_rigids", newcluster)
for var in newcluster.vars:
self._add_variable(var)
self._add_dependency(var, newcluster)
# if there is no root cluster, this one will be it
if len(self._graph.outgoing_vertices("_root")) == 0:
self._graph.add_edge("_root", newcluster)
# add to top level
self._add_top_level(newcluster)
# add to methodgraph
self._mg.add_variable(newcluster)
# notify
self.send_notify(("add", newcluster))
#end def _add_rigid
def _add_hog(self, hog):
diag_print("_add_hog:" + str(hog), "clsolver")
# check if not already exists
if self._graph.has_vertex(hog):
raise StandardError, "hedgehog already in clsolver"
# update graph
self._add_to_group("_hedgehogs", hog)
for var in list(hog.xvars) + [hog.cvar]:
self._add_variable(var)
self._add_dependency(var, hog)
# add to top level
self._add_top_level(hog)
# add to methodgraph
self._mg.add_variable(hog)
# notify
self.send_notify(("add", hog))
def _add_balloon(self, newballoon):
"""add a cluster if not already in system"""
diag_print("_add_balloon " + str(newballoon), "clsolver")
# check if not already exists
if self._graph.has_vertex(newballoon):
raise StandardError, "balloon already in clsolver"
# update graph
self._add_to_group("_balloons", newballoon)
for var in newballoon.vars:
self._add_variable(var)
self._add_dependency(var, newballoon)
# add to top level
self._add_top_level(newballoon)
# add to methodgraph
self._mg.add_variable(newballoon)
# notify
self.send_notify(("add", newballoon))
#end def _add_balloon
def _add_merge(self, merge):
# structural check that method has one output
if len(merge.outputs()) != 1:
raise StandardError, "merge number of outputs != 1"
output = merge.outputs()[0]
# remove any derives from clusters to be merged
#for cluster in merge.inputs():
# outgoing = self.find_dependend(cluster)
# derives = filter(lambda x: isinstance(x, Derive), outgoing)
# for d in derives:
# self._remove(d)
# consistent merge?
consistent = True
for i1 in range(0, len(merge.inputs())):
for i2 in range(i1 + 1, len(merge.inputs())):
c1 = merge.inputs()[i1]
c2 = merge.inputs()[i2]
consistent = consistent and self._is_consistent_pair(c1, c2)
merge.consistent = consistent
# overconstrained cluster?
overconstrained = not consistent
for cluster in merge.inputs():
overconstrained = overconstrained and cluster.overconstrained
output.overconstrained = overconstrained
# add to graph
self._add_cluster(output)
self._add_method(merge)
# remove inputs from toplevel
for cluster in merge.inputs():
self._rem_top_level(cluster)
# add prototype selection method
self._add_prototype_selector(merge)
# add solution selection method
self._add_solution_selector(merge)
def _add_prototype_selector(self, merge):
incluster = merge.outputs()[0]
constraints = merge.prototype_constraints()
if len(constraints) == 0:
return
vars = Set()
for con in constraints:
vars.union_update(con.variables())
selclusters = []
for var in vars:
clusters = self._graph.outgoing_vertices(var)
clusters = filter(lambda c: isinstance(c, Rigid), clusters)
clusters = filter(lambda c: len(c.vars) == 1, clusters)
if len(clusters) != 1:
raise StandardError, "no prototype cluster for variable " + str(
v)
selclusters.append(clusters[0])
outcluster = incluster.copy()
# Rick 20090519 - copy does not copy structural overconstrained flag?
outcluster.overconstrained = incluster.overconstrained
selector = PrototypeMethod(incluster, selclusters, outcluster,
constraints)
self._add_cluster(outcluster)
self._add_method(selector)
self._rem_top_level(incluster)
return
def _add_solution_selector(self, merge):
return
def _add_method(self, method):
diag_print("new " + str(method), "clsolver")
self._add_to_group("_methods", method)
for obj in method.inputs():
self._add_dependency(obj, method)
for obj in method.outputs():
self._add_dependency(method, obj)
self._add_dependency(obj, method)
self._mg.add_method(method)
self.send_notify(("add", method))
# --------------
# search methods
# --------------
def _process_new(self):
while len(self._new) > 0:
newobject = self._new.pop()
diag_print("search from " + str(newobject), "clsolver")
succes = self._search(newobject)
if succes and self.is_top_level(newobject):
# maybe more rules applicable.... push back on stack
self._new.append(newobject)
# while
#end def
def _search(self, newcluster):
raise StandardError, "Not implemented. ClusterSolver is an abstract class, please use ClusterSolver2D or ClusterSolver3D"
def _contains_root(self, input_cluster):
"""returns True iff input_cluster is root cluster or was determined by
merging with the root cluster."""
# start from root cluster. Follow merges upwards until:
# - input cluster found -> True
# - no more merges -> False
if len(self._graph.outgoing_vertices("_root")) > 1:
raise StandardError, "more than one root cluster"
if len(self._graph.outgoing_vertices("_root")) == 1:
cluster = self._graph.outgoing_vertices("_root")[0]
else:
cluster = None
while (cluster != None):
if cluster is input_cluster:
return True
fr = self._graph.outgoing_vertices(cluster)
me = filter(lambda x: isinstance(x, Merge), fr)
me = filter(lambda x: cluster in x.outputs(), me)
if len(me) > 1:
raise StandardError, "root cluster merged more than once"
elif len(me) == 0:
cluster = None
elif len(me[0].outputs()) != 1:
raise StandardError, "a merge with number of outputs != 1"
else:
cluster = me[0].outputs()[0]
#while
return False
#def
def _is_consistent_pair(self, object1, object2):
diag_print(
"in is_consistent_pair " + str(object1) + " " + str(object2),
"clsolver")
oc = over_constraints(object1, object2)
diag_print("over_constraints: " + str(map(str, oc)), "clsolver")
consistent = True
for con in oc:
consistent = consistent and self._consistent_overconstraint_in_pair(
con, object1, object2)
diag_print("global consistent? " + str(consistent), "clsolver")
return consistent
def _consistent_overconstraint_in_pair(self, overconstraint, object1,
object2):
diag_print(
"consistent " + str(overconstraint) + " in " + str(object1) +
" and " + str(object2) + " ?", "clsolver")
# get sources for constraint in given clusters
s1 = self._source_constraint_in_cluster(overconstraint, object1)
s2 = self._source_constraint_in_cluster(overconstraint, object2)
if s1 == None:
consistent = False
elif s2 == None:
consistent = False
elif s1 == s2:
consistent = True
else:
if self._is_atomic(s1) and not self._is_atomic(s2):
consistent = False
elif self._is_atomic(s2) and not self._is_atomic(s1):
consistent = False
else:
consistent = True
#c1to2 = constraits_from_s1_in_s2(s1, s2)
#if solve(c1to2) contains overconstraint then consistent
#c2to1 = constraits_from_s1_in_s2(s2, s1)
#if solve(c2to1) contains overconstraint then consistent
#raise StandardError, "not yet implemented"
diag_print("consistent? " + str(consistent), "clsolver")
return consistent
def _source_constraint_in_cluster(self, constraint, cluster):
if not self._contains_constraint(cluster, constraint):
raise StandardError, "constraint not in cluster"
elif self._is_atomic(cluster):
return cluster
else:
method = self._determining_method(cluster)
inputs = method.inputs()
down = filter(lambda x: self._contains_constraint(x, constraint),
inputs)
if len(down) == 0:
return cluster
elif len(down) > 1:
if method.consistent == True:
return self._source_constraint_in_cluster(
constraint, down[0])
else:
diag_print("Warning: source is inconsistent", "clsolver")
return None
else:
return self._source_constraint_in_cluster(constraint, down[0])
def _is_atomic(self, object):
method = self._determining_method(object)
if method == None:
return True
#elif isinstance(method, Distance2Rigid) or isinstance(method, Angle2Hog):
# return True
else:
return False
def _determining_method(self, object):
depends = self.find_depends(object)
methods = filter(lambda x: isinstance(x, Method), depends)
if len(methods) == 0:
return None
elif len(methods) > 1:
raise "object determined by more than one method"
else:
return methods[0]
def _contains_constraint(self, object, constraint):
if isinstance(constraint, Distance):
return self._contains_distance(object, constraint)
elif isinstance(constraint, Angle):
return self._contains_angle(object, constraint)
else:
raise StandardError, "unexpected case"
def _contains_distance(self, object, distance):
if isinstance(object, Rigid):
return (distance.vars[0] in object.vars
and distance.vars[1] in object.vars)
elif isinstance(object, Distance):
return (distance.vars[0] in object.vars
and distance.vars[1] in object.vars)
else:
return False
def _contains_angle(self, object, angle):
if isinstance(object, Rigid) or isinstance(object, Balloon):
return (angle.vars[0] in object.vars
and angle.vars[1] in object.vars
and angle.vars[2] in object.vars)
elif isinstance(object, Hedgehog):
return (angle.vars[1] == object.cvar
and angle.vars[0] in object.xvars
and angle.vars[2] in object.xvars)
elif isinstance(object, Angle):
return (angle.vars[1] == object.vars[1]
and angle.vars[0] in object.vars
and angle.vars[2] in object.vars)
else:
return False
# --------- special methods ------
def __str__(self):
s = ""
for x in self.distances():
s += str(x) + "\n"
for x in self.angles():
s += str(x) + "\n"
for x in self.rigids():
s += str(x) + "\n"
for x in self.hedgehogs():
s += str(x) + "\n"
for x in self.balloons():
s += str(x) + "\n"
for x in self.methods():
s += str(x) + "\n"
return s
# ---------- older unused methods, kept for possible future use ---------
##def _known_distance(self,a,b):
## """returns Distance or Rigid that contains a and b"""
## # get objects dependend on a and b
## dep_a = self._graph.outgoing_vertices(a)
## dep_b = self._graph.outgoing_vertices(b)
## dependend = []
## for obj in dep_a:
## if obj in dep_b:
## dependend.append(obj)
## # find a Distance
## # distances = filter(lambda x: isinstance(x,Distance), dependend)
## # if len(distances) > 0: return distances[0]
## # or find a Rigid
## clusters = filter(lambda x: isinstance(x,Rigid), dependend)
## clusters = filter(lambda x: self.is_top_level(x), clusters)
## if len(clusters) > 0: return clusters[0]
## # or return None
## return None
##
def _known_angle(self, a, b, c):
"""returns Balloon, Rigid or Hedgehog that contains angle(a, b, c)"""
if a == b or a == c or b == c:
raise StandardError, "all vars in angle must be different"
# get objects dependend on a, b and c
dep_a = self._graph.outgoing_vertices(a)
dep_b = self._graph.outgoing_vertices(b)
dep_c = self._graph.outgoing_vertices(c)
dependend = []
for obj in dep_a:
if obj in dep_b and obj in dep_c:
dependend.append(obj)
# find a hedgehog
hogs = filter(lambda x: isinstance(x, Hedgehog), dependend)
hogs = filter(lambda hog: hog.cvar == b, hogs)
hogs = filter(lambda x: self.is_top_level(x), hogs)
if len(hogs) == 1: return hogs[0]
if len(hogs) > 1: raise "error: angle in more than one hedgehogs"
# or find a cluster
clusters = filter(lambda x: isinstance(x, Rigid), dependend)
clusters = filter(lambda x: self.is_top_level(x), clusters)
if len(clusters) == 1: return clusters[0]
if len(clusters) > 1: raise "error: angle in more than one Rigids"
# or find a balloon
balloons = filter(lambda x: isinstance(x, Balloon), dependend)
balloons = filter(lambda x: self.is_top_level(x), balloons)
if len(balloons) == 1: return balloons[0]
if len(balloons) > 1: raise "error: angle in more than one Balloons"
# or return None
return None
class ClusterSolver(Notifier):
"""
Finds a generic solution for problems formulated by Clusters.
Cluster are added and removed using the add and remove methods.
After adding each Cluster, the solver tries to merge it with
others, resulting in new Clusters.
The generic solution is a directed acyclic graph of Clusters and Methods.
Particilar problems and solutions are represented by a Configuration
for each cluster.
For each Cluster a set of Configurations can be set using the
set method. Configurations are propagated via Methods and can
be retrieved with the get method.
"""
# ------- PUBLIC METHODS --------
def __init__(self, methodclasses):
"""Create a new solver, using the given subclasses of ClusterMethod."""
# init superclasses
Notifier.__init__(self)
# store arguments
self._methodclasses = methodclasses
self._pattern_methods = filter(lambda m: hasattr(m, "patterngraph"),
self._methodclasses)
self._handcoded_methods = filter(
lambda m: hasattr(m, "handcoded_match"), self._methodclasses)
self._incremental_methods = filter(
lambda m: hasattr(m, "incremental_matcher"), self._methodclasses)
# init instance vars
self._graph = Graph()
#self._graph.add_vertex("_root")
# self._graph.add_vertex("_toplevel")
self._graph.add_vertex("_variables")
self._graph.add_vertex("_clusters")
self._graph.add_vertex("_methods")
self._new = []
self._mg = MethodGraph()
# add prototype_selection boolean var to method graph
self._prototype_selection_var = "_prototype_selection_enabled"
self._mg.add_variable(self._prototype_selection_var)
self._mg.set(self._prototype_selection_var, True)
# store map of selection_constraints to SelectionMethod (or None)
self._selection_method = {}
# store root cluster (will be assigned when first cluster added)
self._rootcluster = None
# an incrementally updated toplevel set
self._toplevel = MutableSet()
# incrementally updated set of applicable methods
self._incremental_matchers = map(
lambda method: method.incremental_matcher(self),
self._incremental_methods)
#print "incremental matchers:",self._incremental_matchers
self._applicable_methods = Union(*self._incremental_matchers)
# ------- methods for setting up constraint problems ------------
def add(self, cluster):
"""Add a cluster"""
diag_print("add_cluster " + str(cluster), "clsolver")
self._add_cluster(cluster)
self._process_new()
def remove(self, cluster):
"""Remove a cluster.
All dependend objects are also removed.
"""
self._remove(cluster)
self._process_new()
def set(self, cluster, configurations):
"""Associate a list of configurations with a cluster"""
self._mg.set(cluster, configurations)
def get(self, cluster):
"""Return a set of configurations associated with a cluster"""
return self._mg.get(cluster)
def set_root(self, cluster):
"""Set root cluster, used for positionig and orienting the solutions"""
diag_print("set root " + str(self._rootcluster), "clsolver")
if self._rootcluster != None:
oldrootvar = rootname(self._rootcluster)
self._mg.set(oldrootvar, False)
newrootvar = rootname(cluster)
self._mg.set(newrootvar, True)
self._rootcluster = cluster
def get_root(self):
"""returns current root cluster or None"""
return self._rootcluster
def set_prototype_selection(self, enabled):
"""Enable or disable prototype-based solution selection"""
self._mg.set(self._prototype_selection_var, enabled)
def add_selection_constraint(self, con):
"""Add a SelectionConstraint to filter solutions"""
if con not in self._selection_method:
selector = self._find_selection_method(con)
if selector != None:
selector.add_constraint(con)
self._selection_method[con] = selector
self._mg.execute(selector)
#self._selection_method[con] = None # this line wrong?
self._selection_method[con] = selector # this line better?
def rem_selection_constraint(self, con):
"""Remove a SelectionConstraint"""
if con in self._selection_method:
selector = self._selection_method[con]
if selector != None:
selector.rem_constraint(con)
self._mg.execute(selector)
del self._selection_method[con]
# ------- methods for inspecting the state of the solver ------------
def variables(self):
"""get list of variables"""
return self._graph.outgoing_vertices("_variables")
def clusters(self):
"""get list of clusters"""
return self._graph.outgoing_vertices("_clusters")
def methods(self):
"""get list of methods"""
return self._graph.outgoing_vertices("_methods")
def top_level(self):
"""return IncrementalSet of top-level clusters"""
return self._toplevel
# return self._graph.outgoing_vertices("_toplevel")
def is_top_level(self, object):
"""Returns True iff given cluster is a top-level cluster"""
#return self._graph.has_edge("_toplevel",object)
return object in self._toplevel
def find_dependend(self, object):
"""Return a list of objects that depend on given object directly."""
l = self._graph.outgoing_vertices(object)
return filter(lambda x: self._graph.get(object, x) == "dependency", l)
def find_depends(self, object):
"""Return a list of objects that the given object depends on directly"""
l = self._graph.ingoing_vertices(object)
return filter(lambda x: self._graph.get(x, object) == "dependency", l)
def contains(self, obj):
return self._graph.has_vertex(obj)
# ------------ INTERNALLY USED METHODS --------
# --- dependencies and groups
def _add_dependency(self, on, dependend):
"""Add a dependence for second object on first object"""
self._graph.add_edge(on, dependend, "dependency")
def _add_to_group(self, group, object):
"""Add object to group"""
self._graph.add_edge(group, object, "contains")
def _add_needed_by(self, needed, by):
"""Add relation 'needed' object is needed 'by'"""
self._graph.add_edge(needed, by, "needed_by")
def _objects_that_need(self, needed):
"""Return objects needed by given object"""
l = self._graph.outgoing_vertices(needed)
return filter(lambda x: self._graph.get(needed, x) == "needed_by", l)
def _objects_needed_by(self, needer):
"""Return objects needed by given object"""
l = self._graph.ingoing_vertices(needer)
return filter(lambda x: self._graph.get(x, needer) == "needed_by", l)
def _add_top_level(self, cluster):
# self._graph.add_edge("_toplevel",cluster)
self._new.append(cluster)
self._toplevel.add(cluster)
def _rem_top_level(self, object):
# self._graph.rem_edge("_toplevel",object)
if object in self._new:
self._new.remove(object)
self._toplevel.remove(object)
def _find_descendend(self, v):
"""find all descendend objects of v (i.e.. directly or indirectly dependend)"""
front = [v]
result = {}
while len(front) > 0:
x = front.pop()
if x not in result:
result[x] = 1
front += self.find_dependend(x)
del result[v]
return list(result)
# -- add object types
def _add_variable(self, var):
if not self._graph.has_vertex(var):
diag_print("_add_variable " + str(var), "clsolver")
self._add_to_group("_variables", var)
def _add_cluster(self, newcluster):
diag_print("_add_cluster " + str(newcluster), "clsolver")
# check if not already exists
if self._graph.has_vertex(newcluster):
raise StandardError, "cluster %s already in clsolver" % (
str(newcluster))
# update graph
self._add_to_group("_clusters", newcluster)
for var in newcluster.vars:
self._add_variable(var)
self._add_dependency(var, newcluster)
# add to top level
self._add_top_level(newcluster)
# add to methodgraph
self._mg.add_variable(newcluster)
# add root-variable if needed with default value False
root = rootname(newcluster)
if not self._mg.contains(root):
self._mg.add_variable(root, False)
self._mg.set(root, False)
# add root-variable to dependency graph
self._add_dependency(newcluster, root)
# if there is no root cluster, this one will be it
if self.get_root() == None:
self.set_root(newcluster)
# notify listeners
self.send_notify(("add", newcluster))
def _add_method(self, method):
diag_print("new " + str(method), "clsolver")
self._add_to_group("_methods", method)
for obj in method.inputs():
self._add_dependency(obj, method)
for obj in method.outputs():
self._add_dependency(method, obj)
self._add_dependency(obj, method)
self._mg.add_method(method)
self.send_notify(("add", method))
# ----- solution selection
def _add_prototype_selector(self, merge):
incluster = merge.outputs()[0]
constraints = merge.prototype_constraints()
vars = set()
for con in constraints:
vars.update(con.variables())
selclusters = []
for var in vars:
clusters = self._graph.outgoing_vertices(var)
clusters = filter(lambda c: isinstance(c, Rigid), clusters)
clusters = filter(lambda c: len(c.vars) == 1, clusters)
if len(clusters) < 1:
raise StandardError, "no prototype cluster for variable " + str(
var)
elif len(clusters) > 1:
raise StandardError, "more than one candidate prototype cluster for variable " + str(
var)
selclusters.append(clusters[0])
outcluster = incluster.copy()
selector = PrototypeMethod(incluster, selclusters, outcluster,
constraints, self._prototype_selection_var)
self._add_cluster(outcluster)
self._add_method(selector)
self._rem_top_level(incluster)
return outcluster
def _add_solution_selector(self, incluster):
outcluster = incluster.copy()
selector = SelectionMethod(incluster, outcluster)
constraints = self._find_selection_constraints(incluster)
for con in constraints:
selector.add_constraint(con)
self._selection_method[con] = selector
self._add_cluster(outcluster)
self._add_method(selector)
self._rem_top_level(incluster)
return selector
def _find_selection_method(self, con):
# find clusters containing all constraints vars
candidates = None
for var in con.variables():
# find clusters
clusters = set(self.find_dependend(var))
if candidates == None:
candidates = clusters
else:
candidates = candidates.intersection(clusters)
# get selection methods of clusters
methods = []
for cluster in candidates:
methods += filter(lambda c: isinstance(c, SelectionMethod),
self.find_depends(cluster))
# get selection method with smallest cluster
if len(methods) > 0:
method = min(methods, key=lambda m: len(m.inputs()[0].vars))
return method
else:
return None
##slow implementation, better would be to find method via clustering information in graph
#convars = set(con.variables())
#selmethods = filter(lambda x: isinstance(x,SelectionMethod), self.methods())
#for method in selmethods:
# incluster = method.inputs()[0]
# clvars = set(incluster.vars)
# if clvars.intersection(convars) == convars:
# return method
#return None
def _find_selection_constraints(self, incluster):
applicable = []
for con in self._selection_method:
selector = self._selection_method[con]
if selector == None:
convars = set(con.variables())
clvars = set(incluster.vars)
if convars.intersection(clvars) == convars:
applicable.append(con)
return applicable
# --------------
# isearch methods
# --------------
def _process_new(self):
# try incremental matchers and old style matching alternatingly
non_redundant_methods = filter(
lambda m: not self._is_redundant_method(m),
self._applicable_methods)
while len(non_redundant_methods) > 0 or len(self._new) > 0:
# check incremental matches
if len(non_redundant_methods) > 0:
method = iter(non_redundant_methods).next()
#print "applicable methods:", map(str, self._applicable_methods)
diag_print("incremental search found:" + str(method),
"clsolver._process_new")
self._add_method_complete(method)
else:
newobject = self._new.pop()
diag_print("search from " + str(newobject), "clsolver")
succes = self._search(newobject)
if succes and self.is_top_level(newobject):
# maybe more rules applicable.... push back on stack
self._new.append(newobject)
#endif
# endif
non_redundant_methods = filter(
lambda m: not self._is_redundant_method(m),
self._applicable_methods)
# endwhile
#end def
def _search(self, newcluster):
diag_print("search from:" + str(newcluster), "clsolver3D")
# find all toplevel clusters connected to newcluster
# via one or more variables
connected = set()
for var in newcluster.vars:
dependend = self.find_dependend(var)
dependend = filter(lambda x: self.is_top_level(x), dependend)
connected.update(dependend)
diag_print("search: connected clusters=" + str(connected),
"clsolver3D")
# first try handcoded matching
for methodclass in self._handcoded_methods:
diag_print("trying handcoded match for " + str(methodclass),
"clsolver3D")
matches = methodclass.handcoded_match(self, newcluster, connected)
if self._try_matches(methodclass, matches):
return True
# if incremental matching failed, try full pattern matching
if self._try_methods(connected):
return True
return False
def _try_methods(self, nlet):
"""finds a possible rewrite rule applications on given set of clusters, applies it
and returns True iff successfull
"""
refgraph = reference2graph(nlet)
for methodclass in self._pattern_methods:
diag_print(
"trying generic pattern matching for " + str(methodclass),
"clsolver3D")
matches = gmatch(methodclass.patterngraph, refgraph)
if self._try_matches(methodclass, matches):
return True
# end for match
# end for method
return False
def _try_matches(self, methodclass, matches):
# print "method="+str(methodclass),"number of matches = "+str(len(matches))
for s in matches:
diag_print("try match: " + str(s), "clsolver3D")
method = apply(methodclass, [s])
succes = self._add_method_complete(method)
if succes:
#raw_input()
#print "press key"
return True
else: # WARING: fast bailout, may be incoplete!
return False
# end for match
return False
def _is_information_increasing(self, merge):
# check that the method is information increasing (infinc)
output = merge.outputs()[0]
infinc = True
connected = set()
for var in output.vars:
dependend = self.find_dependend(var)
dependend = filter(lambda x: self.is_top_level(x), dependend)
connected.update(dependend)
# NOTE 07-11-2007 (while writing the paper): this implementation of information increasing may not be correct. We may need to check that the total sum of the information in the overlapping clusters is equal to the information in the output.
for cluster in connected:
if num_constraints(
cluster.intersection(output)) >= num_constraints(output):
infinc = False
break
diag_print("information increasing:" + str(infinc), "clsolver")
return infinc
def _is_cluster_reducing(self, merge):
# check if method reduces number of clusters (reduc)
output = merge.outputs()[0]
nremove = 0
for cluster in merge.input_clusters():
if num_constraints(
cluster.intersection(output)) >= num_constraints(cluster):
# will be removed from toplevel
nremove += 1
# exeption if method sets noremove flag
if hasattr(merge, "noremove") and merge.noremove == True:
nremove = 0
reduc = (nremove > 1)
diag_print("reduce # clusters:" + str(reduc), "clsolver")
return reduc
def _is_redundant_method(self, merge):
# check if the method is redundant (not information increasing and not reducing number of clusters)
infinc = self._is_information_increasing(merge)
reduc = self._is_cluster_reducing(merge)
if not infinc and not reduc:
diag_print("method is redundant", "clsolver")
return True
else:
diag_print("method is not redundant", "clsolver")
return False
def _add_method_complete(self, merge):
diag_print("add_method_complete " + str(merge), "clsolver")
# do not add if method is redundant
if self._is_redundant_method(merge):
return False
output = merge.outputs()[0]
# check consistency and local/global overconstrained
consistent = True
local_oc = False
for i1 in range(0, len(merge.input_clusters())):
for i2 in range(i1 + 1, len(merge.input_clusters())):
c1 = merge.input_clusters()[i1]
c2 = merge.input_clusters()[i2]
if num_constraints(c1.intersection(c2)) != 0:
local_oc = True
consistent = consistent and self._is_consistent_pair(c1, c2)
merge.consistent = consistent
merge.overconstrained = local_oc
# global overconstrained? (store in output cluster)
overconstrained = not consistent
for cluster in merge.input_clusters():
overconstrained = overconstrained or cluster.overconstrained
output.overconstrained = overconstrained
# determine infinc before adding (used later)
infinc = self._is_information_increasing(merge)
# add to graph
self._add_cluster(output)
self._add_method(merge)
# remove input clusters from top_level
merge.restore_toplevel = [] # make restore list in method
for cluster in merge.input_clusters():
# do not remove rigids from toplevel if method does not consider root
if isinstance(cluster, Rigid):
if hasattr(merge, "noremove") and merge.noremove == True:
diag_print("block top-level", "clsolver")
break
# remove input clusters when all its constraints are in output cluster
if num_constraints(
cluster.intersection(output)) >= num_constraints(cluster):
diag_print("remove from top-level: " + str(cluster),
"clsolver")
self._rem_top_level(cluster)
merge.restore_toplevel.append(cluster)
else:
diag_print("keep top-level: " + str(cluster), "clsolver")
# add method to determine root-variable
if hasattr(merge, "noremove") and merge.noremove == True:
self._add_root_false(merge.outputs()[0])
else:
self._add_root_method(merge.input_clusters(), merge.outputs()[0])
# add solution selection methods, only if information increasing
if infinc:
output2 = self._add_prototype_selector(merge)
output3 = self._add_solution_selector(output2)
# success
return True
def _add_root_method(self, inclusters, outcluster):
inroots = []
for cluster in inclusters:
inroots.append(rootname(cluster))
outroot = rootname(outcluster)
method = OrMethod(inroots, outroot)
# add method
self._add_method(method)
# make sure its deleted when cluster is deleted
self._add_dependency(outcluster, method)
def _add_root_false(self, outcluster):
outroot = rootname(outcluster)
method = SetMethod(outroot, False)
# add method
self._add_method(method)
# make sure its deleted when cluster is deleted
self._add_dependency(outcluster, method)
# -- removing objects
def _remove(self, object):
# find all indirectly dependend objects
todelete = [object] + self._find_descendend(object)
torestore = set()
# remove all objects
for item in todelete:
# if merge removed items from toplevel then add them back to top level
if hasattr(item, "restore_toplevel"):
for cluster in item.restore_toplevel:
torestore.add(cluster)
# delete it from graph
diag_print("deleting " + str(item), "clsolver.remove")
self._graph.rem_vertex(item)
# remove from _new list
if item in self._new:
self._new.remove(item)
# remove from incremental top_level
self._toplevel.remove(item)
# remove from methodgraph
if isinstance(item, Method):
# note: method may have been removed because variable removed
try:
self._mg.rem_method(item)
except:
pass
# restore SelectionConstraints
if isinstance(item, SelectionMethod):
for con in item.iter_constraints():
self._selection_method[con] = None
if isinstance(item, MultiVariable):
self._mg.rem_variable(item)
# remove variables with no dependent clusters
if isinstance(item, Cluster):
for var in item.vars:
if len(self.find_dependend(var)) == 0:
self._graph.rem_vertex(var)
# notify listeners
self.send_notify(("remove", item))
# restore toplevel (also added to _new)
for cluster in torestore:
if self._graph.has_vertex(cluster):
self._add_top_level(cluster)
##def _contains_root(self, input_cluster):
## """returns True iff input_cluster is root cluster or was determined by
## merging with the root cluster."""
##
## # start from root cluster. Follow merges upwards until:
## # - input cluster found -> True
## # - no more merges -> False
##
## if len(self._graph.outgoing_vertices("_root")) > 1:
## raise StandardError, "more than one root cluster"
## if len(self._graph.outgoing_vertices("_root")) == 1:
## cluster = self._graph.outgoing_vertices("_root")[0]
## else:
## cluster = None
## while (cluster != None):
## if cluster is input_cluster:
## return True
## fr = self._graph.outgoing_vertices(cluster)
## me = filter(lambda x: isinstance(x, Merge), fr)
## me = filter(lambda x: cluster in x.outputs(), me)
## if len(me) > 1:
## raise StandardError, "root cluster merged more than once"
## elif len(me) == 0:
## cluster = None
## elif len(me[0].outputs()) != 1:
## raise StandardError, "a merge with number of outputs != 1"
## else:
## cluster = me[0].outputs()[0]
## #while
## return False
#def
# ---- consistency
def _is_consistent_pair(self, object1, object2):
diag_print(
"in is_consistent_pair " + str(object1) + " " + str(object2),
"clsolver")
oc = over_constraints(object1, object2)
diag_print("over_constraints: " + str(map(str, oc)), "clsolver")
consistent = True
for con in oc:
consistent = consistent and self._consistent_overconstraint_in_pair(
con, object1, object2)
diag_print("global consistent? " + str(consistent), "clsolver")
return consistent
def _consistent_overconstraint_in_pair(self, overconstraint, object1,
object2):
diag_print(
"consistent " + str(overconstraint) + " in " + str(object1) +
" and " + str(object2) + " ?", "clsolver")
# get sources for constraint in given clusters
s1 = self._source_constraint_in_cluster(overconstraint, object1)
s2 = self._source_constraint_in_cluster(overconstraint, object2)
if s1 == None:
consistent = False
elif s2 == None:
consistent = False
elif s1 == s2:
consistent = True
else:
if self._is_atomic(s1) and not self._is_atomic(s2):
consistent = False
elif self._is_atomic(s2) and not self._is_atomic(s1):
consistent = False
else:
consistent = True
#c1to2 = constraits_from_s1_in_s2(s1, s2)
#if solve(c1to2) contains overconstraint then consistent
#c2to1 = constraits_from_s1_in_s2(s2, s1)
#if solve(c2to1) contains overconstraint then consistent
#raise StandardError, "not yet implemented"
diag_print("consistent? " + str(consistent), "clsolver")
return consistent
def _source_constraint_in_cluster(self, constraint, cluster):
if not self._contains_constraint(cluster, constraint):
raise StandardError, "constraint not in cluster"
elif self._is_atomic(cluster):
return cluster
else:
method = self._determining_method(cluster)
inputs = method.inputs()
down = filter(lambda x: self._contains_constraint(x, constraint),
inputs)
if len(down) == 0:
return cluster
elif len(down) > 1:
if method.consistent == True:
return self._source_constraint_in_cluster(
constraint, down[0])
else:
diag_print("Warning: source is inconsistent", "clsolver")
return None
else:
return self._source_constraint_in_cluster(constraint, down[0])
def _is_atomic(self, object):
method = self._determining_method(object)
if method == None:
return True
#elif isinstance(method, Distance2Rigid) or isinstance(method, Angle2Hog):
# return True
else:
return False
def _determining_method(self, object):
depends = self.find_depends(object)
methods = filter(lambda x: isinstance(x, Method), depends)
if len(methods) == 0:
return None
elif len(methods) > 1:
raise "object determined by more than one method"
else:
return methods[0]
def _contains_constraint(self, object, constraint):
if isinstance(constraint, Distance):
return self._contains_distance(object, constraint)
elif isinstance(constraint, Angle):
return self._contains_angle(object, constraint)
else:
raise StandardError, "unexpected case"
def _contains_distance(self, object, distance):
if isinstance(object, Rigid):
return (distance.vars[0] in object.vars
and distance.vars[1] in object.vars)
elif isinstance(object, Distance):
return (distance.vars[0] in object.vars
and distance.vars[1] in object.vars)
else:
return False
def _contains_angle(self, object, angle):
if isinstance(object, Rigid) or isinstance(object, Balloon):
return (angle.vars[0] in object.vars
and angle.vars[1] in object.vars
and angle.vars[2] in object.vars)
elif isinstance(object, Hedgehog):
return (angle.vars[1] == object.cvar
and angle.vars[0] in object.xvars
and angle.vars[2] in object.xvars)
elif isinstance(object, Angle):
return (angle.vars[1] == object.vars[1]
and angle.vars[0] in object.vars
and angle.vars[2] in object.vars)
else:
return False
# --------- special methods ------
def __str__(self):
s = ""
s += "Clusters:\n"
for x in self.clusters():
s += str(x) + "\n"
s += "Methods:\n"
for x in self.methods():
s += str(x) + "\n"
return s