Simplified output of GeometricSolver.get_cluster.

New decompositionView (replacing compositionView) in workbench
This commit is contained in:
kwikrick 2009-11-16 20:01:47 +00:00
parent fd0438c86d
commit 38c71c882b
7 changed files with 432 additions and 946 deletions

View File

@ -149,7 +149,8 @@ class ClusterSolver3D(ClusterSolver):
# end for match
# end for method
return False
def _add_method_complete(self, merge):
# diag_print("add_method_complete "+str(merge), "clsolver3D")
# check that method has one output

View File

@ -311,16 +311,26 @@ class GeometricSolver (Listener):
def get_cluster(self):
"""Returns a GeometricCluster (the root of a tree of clusters),
describing the solutions and the decomposition of the problem."""
# several drcluster can maps to a single geoclusters
map = {}
geoclusters = []
# map dr clusters
for drcluster in self.dr.rigids():
# create geo cluster and map to drcluster (and vice versa)
geocluster = GeometricCluster()
map[drcluster] = geocluster
map[geocluster] = drcluster
# determine variables
for var in drcluster.vars:
geocluster.variables.append(var)
# create geocluster and map to drcluster (and vice versa)
geocluster = GeometricCluster(drcluster.vars)
if geocluster not in map:
map[drcluster] = geocluster
map[geocluster] = [drcluster]
geoclusters.append(geocluster)
else:
geocluster = map[map[geocluster][0]]
map[drcluster] = geocluster
map[geocluster].append(drcluster)
for geocluster in geoclusters:
# pick drcluster with fewest solutions
drclusters = map[geocluster]
drcluster = min(drclusters, key=lambda c: len(self.dr.get(drcluster)))
# determine solutions
solutions = self.dr.get(drcluster)
underconstrained = False
@ -332,44 +342,33 @@ class GeometricSolver (Listener):
# determine flag
if drcluster.overconstrained:
geocluster.flag = GeometricCluster.S_OVER
elif geocluster.solutions == None:
geocluster.flag = GeometricCluster.UNSOLVED
elif len(geocluster.solutions) == 0:
geocluster.flag = GeometricCluster.I_OVER
elif underconstrained:
geocluster.flag = GeometricCluster.I_UNDER
else:
geocluster.flag = GeometricCluster.OK
# determine subclusters
for method in self.dr.methods():
if not isinstance(method, PrototypeMethod) and not isinstance(method, SelectionMethod):
for out in method.outputs():
if isinstance(out, Rigid):
parent = map[out]
for inp in method.inputs():
if isinstance(inp, Rigid):
parent.subs.append(map[inp])
sub = map[inp]
if sub != parent:
parent.subs.append(sub)
# combine clusters due to selection
if True:
for method in self.dr.methods():
if isinstance(method, PrototypeMethod):
incluster = method.inputs()[0]
outcluster = method.outputs()[0]
geoin = map[incluster]
geoout = map[outcluster]
geoout.subs = list(geoin.subs)
for method in self.dr.methods():
if isinstance(method, SelectionMethod):
incluster = method.inputs()[0]
outcluster = method.outputs()[0]
geoin = map[incluster]
geoout = map[outcluster]
geoout.subs = list(geoin.subs)
# determine top-level result
rigids = filter(lambda c: isinstance(c, Rigid), self.dr.top_level())
if len(rigids) == 0:
# no variables in problem?
result = GeometricCluster()
result = GeometricCluster(self.problem.cg.variables())
result.variables = []
result.subs = []
result.solutions = []
@ -379,12 +378,13 @@ class GeometricSolver (Listener):
result = map[rigids[0]]
else:
# structurally underconstrained cluster
result = GeometricCluster()
result = GeometricCluster(self.problem.cg.variables())
result.flag = GeometricCluster.S_UNDER
for rigid in rigids:
result.subs.append(map[rigid])
return result
def get_solutions(self):
"""Returns a list of Configurations, which will be empty if the
problem has no solutions. Note: this method is
@ -647,13 +647,22 @@ class GeometricCluster:
UNSOLVED = "unsolved"
EMPTY = "empty"
def __init__(self):
def __init__(self, variables):
"""initialise an empty new cluster"""
self.variables = []
self.variables = frozenset(variables)
self.solutions = []
self.subs = []
self.flag = GeometricCluster.OK
def __eq__(self, other):
if isinstance(other, GeometricCluster):
return self.variables == other.variables
else:
return False
def __hash__(self):
return hash(self.variables)
def __str__(self):
return self._str_recursive()
@ -679,7 +688,7 @@ class GeometricCluster:
s = s + spaces + "|...\n"
# pritn cluster
s = spaces + "cluster " + str(result.variables) + " " + str(result.flag) + " " + str(len(result.solutions)) + " solutions\n" + s
s = spaces + "cluster " + str(list(result.variables)) + " " + str(result.flag) + " " + str(len(result.solutions)) + " solutions\n" + s
return s
# def

View File

@ -5,324 +5,324 @@ from cvitems import CVCluster, CVPoint, CVInfoOverlay, CVConnection
from parameters import Settings
class CompositionView(QtGui.QDialog):
""" A view where the decomposition of the system of constraints is visualised as a tree """
def __init__(self, viewport, viewportMngr, vpType, prototypeMngr, parent=None):
""" Initialization of the CompositionView class
Parameters:
viewportMngr - the manager of the viewports where the composition view can reside in
prototypeMngr - the manager of the prototypes is used to obtain the results of the solver
"""
QtGui.QDialog.__init__(self, parent)
self.prototypeManager = prototypeMngr
self.viewport = viewport
self.viewportManager = viewportMngr
self.settings = Settings()
self.setWindowFlags(QtCore.Qt.Window)
self.timer = QtCore.QObject()
#QtCore.qsrand(QtCore.QTime(0,0,0).secsTo(QtCore.QTime.currentTime()))
self.tree = Tree(None)
self.infoOverlay = CVInfoOverlay(self)
self.connections = []
self.ui = Ui_compositionView()
self.ui.setupUi(self)
self.ui.graphicsView.setupViewport(QtOpenGL.QGLWidget(QtOpenGL.QGLFormat(QtOpenGL.QGL.SampleBuffers|QtOpenGL.QGL.DoubleBuffer)))
#self.ui.graphicsView.setViewport(QtGui.QWidget())
self.ui.graphicsView.setRenderHints(QtGui.QPainter.Antialiasing | QtGui.QPainter.SmoothPixmapTransform)
self.collapsed = False
self.currentTool = None
self.viewportType = vpType
self.first = False
self.nodeId = 0
""" A view where the decomposition of the system of constraints is visualised as a tree """
def __init__(self, viewport, viewportMngr, vpType, prototypeMngr, parent=None):
""" Initialization of the CompositionView class
Parameters:
viewportMngr - the manager of the viewports where the composition view can reside in
prototypeMngr - the manager of the prototypes is used to obtain the results of the solver
"""
QtGui.QDialog.__init__(self, parent)
self.prototypeManager = prototypeMngr
self.viewport = viewport
self.viewportManager = viewportMngr
self.settings = Settings()
self.setWindowFlags(QtCore.Qt.Window)
self.timer = QtCore.QObject()
#QtCore.qsrand(QtCore.QTime(0,0,0).secsTo(QtCore.QTime.currentTime()))
self.tree = Tree(None)
self.infoOverlay = CVInfoOverlay(self)
self.connections = []
self.ui = Ui_compositionView()
self.ui.setupUi(self)
self.ui.graphicsView.setupViewport(QtOpenGL.QGLWidget(QtOpenGL.QGLFormat(QtOpenGL.QGL.SampleBuffers|QtOpenGL.QGL.DoubleBuffer)))
#self.ui.graphicsView.setViewport(QtGui.QWidget())
self.ui.graphicsView.setRenderHints(QtGui.QPainter.Antialiasing | QtGui.QPainter.SmoothPixmapTransform)
self.collapsed = False
self.currentTool = None
self.viewportType = vpType
self.first = False
self.nodeId = 0
self.overConstrainedColor = QtGui.QColor(0,0,255)
self.underConstrainedColor = QtGui.QColor(255,0,0)
self.wellConstrainedColor = QtGui.QColor(0,255,0)
self.unsolvedColor = QtGui.QColor(125,124,255)
self.setScene()
self.createTriggers()
def createTriggers(self):
""" Create the triggers for the components in the graphical window """
QtCore.QObject.connect(self.ui.zoomInButton,QtCore.SIGNAL("clicked()"),self.zoomIn)
QtCore.QObject.connect(self.ui.zoomOutButton,QtCore.SIGNAL("clicked()"),self.zoomOut)
QtCore.QObject.connect(self.ui.fitButton, QtCore.SIGNAL("clicked()"), self.fit)
QtCore.QObject.connect(self.ui.collapseButton, QtCore.SIGNAL("clicked()"), self.collapse)
QtCore.QObject.connect(self.ui.graphicsScene, QtCore.SIGNAL("changed(const QList<QRectF> & )"), self.updateSceneRect)
QtCore.QObject.connect(self.ui.verticalSlider,QtCore.SIGNAL("valueChanged(int)"),self.setupMatrix)
QtCore.QObject.connect(self.settings.dvData,QtCore.SIGNAL("treeOrientationChanged()"), self.updateTreeOrientation)
def setScene(self):
""" The scene where the tree is visualised in, will be created and set """
self.initView()
def getViewportType(self):
return self.viewportType
def updateGL(self):
self.update()
def createDecomposition(self):
""" Create a new decomposition. If an older one exists it will be removed. """
if self.ui.graphicsScene != None:
for item in self.ui.graphicsView.items():
item.hide()
if item.parentItem() == None:
self.ui.graphicsScene.removeItem(item)
if self.tree.root != None:
self.tree.clear(self.tree.root)
del self.connections[:]
del self.settings.dvData.fixedClusterIds[:]
self.initView()
def initView(self):
""" Updating the view with new data and nodes for the visualisation of the tree """
if self.prototypeManager.result != None:
self.nodeId = 0
self.tree.root = self.populateTree(self.prototypeManager.result.subs, None, self.prototypeManager.result)
# return # Rick 20090522 debug
self.drawTree(self.ui.graphicsScene, self.tree.root, self.tree.root.children)
self.drawConnections(self.ui.graphicsScene)
self.determineCollapse(self.tree.root)
self.showConnections()
self.tree.root.showChildren()
self.updateTree()
self.addInfoOverlay()
self.initFixStates()
def updateViewports(self):
self.viewportManager.updateViewports()
def updateTree(self):
""" Update the tree, where the node positions and connections between the nodes are updated """
self.tree.clear(self.tree.root)
self.tree.updateTree()
self.updateNodePositions(self.tree.root)
self.showConnections()
def populateTree(self, nodes, rootNode, currentNode, id=0):
""" Recursive function to populate a tree, from the results of the solver to finally display it in the Decomposition View.
The population is depth first.
Parameters:
nodes - the childnodes
rootNode - root node of the (partial) tree
currentNode - the current node of the result obtained from the constraints solver
"""
if len(currentNode.variables) == 1:
self.createLeafPoint(rootNode, currentNode.variables[0], self.nodeId)
else:
newNode = CVCluster(self, rootNode, self.nodeId)
newNode.flag = currentNode.flag
newNode.variables = currentNode.variables
needCollapse = False
""" Add children to the rootNode to create the full tree """
if rootNode != None:
#self.setCollapse(newNode)
rootNode.children += [newNode]
""" Create a connection between the nodes if the current node has a rootnode"""
newConnection = CVConnection(self, rootNode, newNode)
self.connections += [newConnection]
""" get the leaf nodes """
if len(nodes) == 0:
for variable in newNode.variables:
self.createLeafPoint(newNode, variable, self.nodeId)
for node in nodes:
self.nodeId += 1
self.populateTree(node.subs, newNode, node, self.nodeId)
""" To return the whole tree, a check will be performed for the rootnode """
if rootNode == None:
return newNode
def initFixStates(self):
""" Initialize the fix states from another view if available """
for fixedId in self.settings.dvData.fixedClusterIds:
self.updateState(fixedId, True, self.tree.root)
def stateChange(self, id, fixed):
""" Change the state of the cluster which might be fixed and report it
to the other decomposition views.
Paramaters:
id - unique id of the cluster
fixed - should the clusters be fixed or not
"""
self.viewportManager.updateDecompositionFixed(id, fixed)
if fixed:
self.settings.dvData.fixedClusterIds += [id]
elif not fixed:
self.settings.dvData.fixedClusterIds = filter(lambda x:x!=id, self.settings.dvData.fixedClusterIds)
def updateState(self, id, fixed, rootNode):
""" Update the fixed cluster, with the visuals.
Parameters:
id - unique id of the cluster
fixed - should the cluster be fixed or not
rootNode - recursive funcion to walk the tree
"""
if rootNode.identifier == id:
if fixed and rootNode.isVisible():
rootNode.fixGraphic.show()
rootNode.clusterActive = True
elif fixed and not rootNode.isVisible():
rootNode.fixGraphic.hide()
rootNode.clusterActive = True
else:
rootNode.fixGraphic.hide()
rootNode.clusterActive = False
self.prototypeManager.removeClusterObjects([rootNode.permCluster], True, True)
rootNode.permCluster = None
return True
for node in rootNode.children:
found = self.updateState(id, fixed, node)
if found:
break
return False
def createLeafPoint(self, node, variable, id):
cvPoint = CVPoint(self, node, id)
cvPoint.setWidthAndHeight(20, 20)
cvPoint.prtRef = self.prototypeManager.getObjectByKey(variable)
cvPoint.isCollapsed = False
cvPoint.canCollapse = False
#cvPoint.setInfoOverlay()
node.children += [cvPoint]
newConnection = CVConnection(self, node, cvPoint)
self.connections += [newConnection]
def setCollapse(self, node):
node.isCollapsed = False
if not isinstance(node, CVPoint):
if not node.collapseFromResult():
node.updateCluster()
def determineCollapse(self, node):
self.setCollapse(node)
for child in node.children:
self.determineCollapse(child)
def addInfoOverlay(self):
self.ui.graphicsScene.addItem(self.infoOverlay)
self.infoOverlay.hide()
def drawTree(self, scene, root, childNodes):
""" The different nodes are added to the scene and will automatically be drawn
Parameters:
scene - the scene where the rootnode has to be drawn in
root - the rootnode of the (sub-) tree
childNode - the children of this root node
"""
root.setPos(root.position)
scene.addItem(root)
#print "#nodes: ", len(childNodes), " position: ",root.position.x(), " " , root.position.y()
self.overConstrainedColor = QtGui.QColor(0,0,255)
self.underConstrainedColor = QtGui.QColor(255,0,0)
self.wellConstrainedColor = QtGui.QColor(0,255,0)
self.unsolvedColor = QtGui.QColor(125,124,255)
self.setScene()
self.createTriggers()
def createTriggers(self):
""" Create the triggers for the components in the graphical window """
QtCore.QObject.connect(self.ui.zoomInButton,QtCore.SIGNAL("clicked()"),self.zoomIn)
QtCore.QObject.connect(self.ui.zoomOutButton,QtCore.SIGNAL("clicked()"),self.zoomOut)
QtCore.QObject.connect(self.ui.fitButton, QtCore.SIGNAL("clicked()"), self.fit)
QtCore.QObject.connect(self.ui.collapseButton, QtCore.SIGNAL("clicked()"), self.collapse)
QtCore.QObject.connect(self.ui.graphicsScene, QtCore.SIGNAL("changed(const QList<QRectF> & )"), self.updateSceneRect)
QtCore.QObject.connect(self.ui.verticalSlider,QtCore.SIGNAL("valueChanged(int)"),self.setupMatrix)
QtCore.QObject.connect(self.settings.dvData,QtCore.SIGNAL("treeOrientationChanged()"), self.updateTreeOrientation)
def setScene(self):
""" The scene where the tree is visualised in, will be created and set """
self.initView()
def getViewportType(self):
return self.viewportType
def updateGL(self):
self.update()
def createDecomposition(self):
""" Create a new decomposition. If an older one exists it will be removed. """
if self.ui.graphicsScene != None:
for item in self.ui.graphicsView.items():
item.hide()
if item.parentItem() == None:
self.ui.graphicsScene.removeItem(item)
if self.tree.root != None:
self.tree.clear(self.tree.root)
del self.connections[:]
del self.settings.dvData.fixedClusterIds[:]
self.initView()
def initView(self):
""" Updating the view with new data and nodes for the visualisation of the tree """
if self.prototypeManager.result != None:
self.nodeId = 0
self.tree.root = self.populateTree(self.prototypeManager.result.subs, None, self.prototypeManager.result)
self.drawTree(self.ui.graphicsScene, self.tree.root, self.tree.root.children)
self.drawConnections(self.ui.graphicsScene)
self.determineCollapse(self.tree.root)
self.showConnections()
self.tree.root.showChildren()
self.updateTree()
self.addInfoOverlay()
self.initFixStates()
def updateViewports(self):
self.viewportManager.updateViewports()
def updateTree(self):
""" Update the tree, where the node positions and connections between the nodes are updated """
self.tree.clear(self.tree.root)
self.tree.updateTree()
self.updateNodePositions(self.tree.root)
self.showConnections()
def populateTree(self, nodes, rootNode, currentNode, id=0):
""" Recursive function to populate a tree, from the results of the solver to finally display it in the Decomposition View.
The population is depth first.
Parameters:
nodes - the childnodes
rootNode - root node of the (partial) tree
currentNode - the current node of the result obtained from the constraints solver
"""
if len(currentNode.variables) == 1:
self.createLeafPoint(rootNode, currentNode.variables[0], self.nodeId)
else:
newNode = CVCluster(self, rootNode, self.nodeId)
newNode.flag = currentNode.flag
newNode.variables = currentNode.variables
needCollapse = False
""" Add children to the rootNode to create the full tree """
if rootNode != None:
#self.setCollapse(newNode)
rootNode.children += [newNode]
""" Create a connection between the nodes if the current node has a rootnode"""
newConnection = CVConnection(self, rootNode, newNode)
self.connections += [newConnection]
""" get the leaf nodes """
if len(nodes) == 0:
for variable in newNode.variables:
self.createLeafPoint(newNode, variable, self.nodeId)
# Rick 20091116 - skip this for debug
# for node in nodes:
# self.nodeId += 1
# self.populateTree(node.subs, newNode, node, self.nodeId)
""" To return the whole tree, a check will be performed for the rootnode """
if rootNode == None:
return newNode
def initFixStates(self):
""" Initialize the fix states from another view if available """
for fixedId in self.settings.dvData.fixedClusterIds:
self.updateState(fixedId, True, self.tree.root)
def stateChange(self, id, fixed):
""" Change the state of the cluster which might be fixed and report it
to the other decomposition views.
Paramaters:
id - unique id of the cluster
fixed - should the clusters be fixed or not
"""
self.viewportManager.updateDecompositionFixed(id, fixed)
if fixed:
self.settings.dvData.fixedClusterIds += [id]
elif not fixed:
self.settings.dvData.fixedClusterIds = filter(lambda x:x!=id, self.settings.dvData.fixedClusterIds)
def updateState(self, id, fixed, rootNode):
""" Update the fixed cluster, with the visuals.
Parameters:
id - unique id of the cluster
fixed - should the cluster be fixed or not
rootNode - recursive funcion to walk the tree
"""
if rootNode.identifier == id:
if fixed and rootNode.isVisible():
rootNode.fixGraphic.show()
rootNode.clusterActive = True
elif fixed and not rootNode.isVisible():
rootNode.fixGraphic.hide()
rootNode.clusterActive = True
else:
rootNode.fixGraphic.hide()
rootNode.clusterActive = False
self.prototypeManager.removeClusterObjects([rootNode.permCluster], True, True)
rootNode.permCluster = None
return True
for node in rootNode.children:
found = self.updateState(id, fixed, node)
if found:
break
return False
def createLeafPoint(self, node, variable, id):
cvPoint = CVPoint(self, node, id)
cvPoint.setWidthAndHeight(20, 20)
cvPoint.prtRef = self.prototypeManager.getObjectByKey(variable)
cvPoint.isCollapsed = False
cvPoint.canCollapse = False
#cvPoint.setInfoOverlay()
node.children += [cvPoint]
newConnection = CVConnection(self, node, cvPoint)
self.connections += [newConnection]
def setCollapse(self, node):
node.isCollapsed = False
if not isinstance(node, CVPoint):
if not node.collapseFromResult():
node.updateCluster()
def determineCollapse(self, node):
self.setCollapse(node)
for child in node.children:
self.determineCollapse(child)
def addInfoOverlay(self):
self.ui.graphicsScene.addItem(self.infoOverlay)
self.infoOverlay.hide()
def drawTree(self, scene, root, childNodes):
""" The different nodes are added to the scene and will automatically be drawn
Parameters:
scene - the scene where the rootnode has to be drawn in
root - the rootnode of the (sub-) tree
childNode - the children of this root node
"""
root.setPos(root.position)
scene.addItem(root)
#print "#nodes: ", len(childNodes), " position: ",root.position.x(), " " , root.position.y()
for node in childNodes:
self.drawTree(scene, node, node.children)
def drawConnections(self, scene):
""" The connections between the nodes are added to the scene and will automatically be drawn
Parameters:
scene - the scene where the connections has to be drawn in
"""
for connection in self.connections:
#connection.setPos()
scene.addItem(connection)
def showConnections(self):
""" Show/hide the connections between the nodes, this depends if the node is collapsed """
for connection in self.connections:
connection.setPos(connection.nodeTo.position)
if connection.nodeFrom.isCollapsed or (connection.nodeTo.isVisible() == False):
connection.hide()
else:
connection.show()
def updateConnections(self):
for connection in self.connections:
connection.update()
def nrVisibleConnections(self):
number = 0
#for connection in self.connections:
#print "x, y: " , connection.x(), connection.y()
#print "nr of visible connections: " , number
def updateNodePositions(self, node):
""" Map the position of the nodes in the tree on the graphical view
Parameters:
node - a node in the tree for which the position is set
"""
node.setPos(node.position)
for node in childNodes:
self.drawTree(scene, node, node.children)
def drawConnections(self, scene):
""" The connections between the nodes are added to the scene and will automatically be drawn
Parameters:
scene - the scene where the connections has to be drawn in
"""
for connection in self.connections:
#connection.setPos()
scene.addItem(connection)
def showConnections(self):
""" Show/hide the connections between the nodes, this depends if the node is collapsed """
for connection in self.connections:
connection.setPos(connection.nodeTo.position)
if connection.nodeFrom.isCollapsed or (connection.nodeTo.isVisible() == False):
connection.hide()
else:
connection.show()
def updateConnections(self):
for connection in self.connections:
connection.update()
def nrVisibleConnections(self):
number = 0
#for connection in self.connections:
#print "x, y: " , connection.x(), connection.y()
#print "nr of visible connections: " , number
def updateNodePositions(self, node):
""" Map the position of the nodes in the tree on the graphical view
Parameters:
node - a node in the tree for which the position is set
"""
node.setPos(node.position)
for childNode in node.children:
self.updateNodePositions(childNode)
for childNode in node.children:
self.updateNodePositions(childNode)
def updateSceneRect(self, rectList=None):
self.ui.graphicsScene.setSceneRect(self.ui.graphicsScene.itemsBoundingRect())
def updateTreeOrientation(self):
self.tree.orientation = self.settings.dvData.treeAlignment
def zoomIn(self):
""" Zoom in the graphics view, by updating the vertical slider """
self.ui.verticalSlider.setValue(self.ui.verticalSlider.value() + 1)
def zoomOut(self):
""" Zoom out the graphics view, by updating the vertical slider """
self.ui.verticalSlider.setValue(self.ui.verticalSlider.value() - 1)
def fit(self):
""" Fits the tree exactly in the graphics view """
self.ui.graphicsView.fitInView(0.0, 0.0, self.ui.graphicsScene.width(), self.ui.graphicsScene.height(), QtCore.Qt.KeepAspectRatio)
""" Update the slider """
value = (math.log(self.ui.graphicsView.matrix().m11(),2)*50) + 250.0
self.ui.verticalSlider.setValue(value)
def collapseAll(self, node):
if node.canCollapse:
node.collapse()
for childNode in node.children:
self.collapseAll(childNode)
def expandAll(self, node):
node.expand()
for childNode in node.children:
self.expandAll(childNode)
def collapse(self):
if self.collapsed:
self.collapsed = False
self.collapseAll(self.tree.root)
else:
self.collapsed = True
self.expandAll(self.tree.root)
self.updateTree()
self.update()
def setupMatrix(self, value):
""" Zoom in/out the graphics view, depending on the value of the slider
Parameters
value - value of the updated slider
"""
scale = math.pow(2.0, (self.ui.verticalSlider.value()-250.0)/50.0)
matrix = QtGui.QMatrix()
matrix.scale(scale,scale)
def updateSceneRect(self, rectList=None):
self.ui.graphicsScene.setSceneRect(self.ui.graphicsScene.itemsBoundingRect())
def updateTreeOrientation(self):
self.tree.orientation = self.settings.dvData.treeAlignment
def zoomIn(self):
""" Zoom in the graphics view, by updating the vertical slider """
self.ui.verticalSlider.setValue(self.ui.verticalSlider.value() + 1)
def zoomOut(self):
""" Zoom out the graphics view, by updating the vertical slider """
self.ui.verticalSlider.setValue(self.ui.verticalSlider.value() - 1)
def fit(self):
""" Fits the tree exactly in the graphics view """
self.ui.graphicsView.fitInView(0.0, 0.0, self.ui.graphicsScene.width(), self.ui.graphicsScene.height(), QtCore.Qt.KeepAspectRatio)
""" Update the slider """
value = (math.log(self.ui.graphicsView.matrix().m11(),2)*50) + 250.0
self.ui.verticalSlider.setValue(value)
def collapseAll(self, node):
if node.canCollapse:
node.collapse()
for childNode in node.children:
self.collapseAll(childNode)
def expandAll(self, node):
node.expand()
for childNode in node.children:
self.expandAll(childNode)
def collapse(self):
if self.collapsed:
self.collapsed = False
self.collapseAll(self.tree.root)
else:
self.collapsed = True
self.expandAll(self.tree.root)
self.updateTree()
self.update()
def setupMatrix(self, value):
""" Zoom in/out the graphics view, depending on the value of the slider
Parameters
value - value of the updated slider
"""
scale = math.pow(2.0, (self.ui.verticalSlider.value()-250.0)/50.0)
matrix = QtGui.QMatrix()
matrix.scale(scale,scale)
self.ui.graphicsView.setMatrix(matrix)
self.ui.graphicsView.setMatrix(matrix)

View File

@ -1,601 +1,77 @@
from includes import *
from tree import Node
from geosolver import GeometricCluster
from parameters import Settings
class CVCluster(QtGui.QGraphicsItem, Node):
""" Visualisation of the clusters (nodes) in the decompositionView """
def __init__(self, compView, parentNode, id, parent=None):
QtGui.QGraphicsItem.__init__(self, parent)
Node.__init__(self, parentNode)
self.compositionView = compView
self.setFlags(QtGui.QGraphicsItem.ItemIsSelectable)
self.setAcceptsHoverEvents(True)
self.startAngle = 0
self.spanAngle = 0
self.paintRect = QtCore.QRectF(0, 0, self.width, self.height)
self.boundary = QtCore.QRectF(0.0, 0.0, 0.0, 0.0)
self.fixGraphic = QtGui.QGraphicsSimpleTextItem("F", self)
self.identifier = id
self.bezierCurve = None
self.initAngles()
self.bound = QtCore.QRectF()
self.updateBound()
self.flag = None
self.clusterHighlight = None
self.permCluster = None
self.clusterActive = False
self.fixGraphic.hide()
def initAngles(self):
""" Initialize the angles for the visual representation of the nodes, these are dependent on the orientation of the tree """
self.startAngle = 60 * 16
self.spanAngle = 60 * 16
if self.compositionView.tree.orientation == TreeOrientation.BOTTOM:
self.startAngle = -self.startAngle
self.spanAngle = -self.spanAngle
elif self.compositionView.tree.orientation == TreeOrientation.LEFT:
self.startAngle = self.startAngle + 90 * 16
elif self.compositionView.tree.orientation == TreeOrientation.RIGHT:
self.startAngle = self.startAngle - 90 * 16
def updateBound(self):
""" The bound where the user can click in to do a certain action, is set here. This bound is tightly set around the object """
pointBegin = QtCore.QPointF(0.0, 0.0)
pointBegin.setX((self.paintRect.width()/2.0) * math.cos(math.radians(self.startAngle/16.0)))
pointBegin.setY((self.paintRect.height()/2.0) * math.sin(math.radians(self.startAngle/16.0)))
pointEnd = QtCore.QPointF(0.0, 0.0)
pointEnd.setX((self.paintRect.width()/2.0) * math.cos(math.radians((self.startAngle+self.spanAngle)/16.0)))
pointEnd.setY((self.paintRect.height()/2.0) * math.sin(math.radians((self.startAngle+self.spanAngle)/16.0)))
pointMiddle = QtCore.QPointF(0.0, 0.0)
halfDegree = (self.startAngle+(self.spanAngle/2.0))/16.0
pointMiddle.setX((self.paintRect.width()/2.0) * math.cos(math.radians(halfDegree)))
pointMiddle.setY((self.paintRect.height()/2.0) * math.sin(math.radians(halfDegree)))
if pointBegin.x() < pointMiddle.x() and pointBegin.x() < pointEnd.x():
self.boundary.setLeft(pointBegin.x())
elif pointMiddle.x() < pointEnd.x():
self.boundary.setLeft(pointMiddle.x())
else:
self.boundary.setLeft(pointEnd.x())
if self.boundary.left() > 0.0:
self.boundary.setLeft(0.0)
if pointBegin.x() > pointMiddle.x() and pointBegin.x() > pointEnd.x():
self.boundary.setRight(pointBegin.x())
elif pointMiddle.x() > pointEnd.x():
self.boundary.setRight(pointMiddle.x())
else:
self.boundary.setRight(pointEnd.x())
if self.boundary.right() < 0.0:
self.boundary.setRight(0.0)
if pointBegin.y() < pointMiddle.y() and pointBegin.y() < pointEnd.y():
self.boundary.setBottom(pointBegin.y())
elif pointMiddle.y() < pointEnd.y():
self.boundary.setBottom(pointMiddle.y())
else:
self.boundary.setBottom(pointEnd.y())
if self.boundary.bottom() > 0.0:
self.boundary.setBottom(0.0)
if pointBegin.y() > pointMiddle.y() and pointBegin.y() > pointEnd.y():
self.boundary.setTop(pointBegin.y())
elif pointMiddle.y() > pointEnd.y():
self.boundary.setTop(pointMiddle.y())
else:
self.boundary.setTop(pointEnd.y())
if self.boundary.top() < 0.0:
self.boundary.setTop(0.0)
self.__translateBound()
class CVCluster(QtGui.QGraphicsItem):
""" Visualisation of the clusters (nodes) in the decompositionView """
def __init__(self, compView, cluster, x,y):
QtGui.QGraphicsItem.__init__(self)
self.compositionView = compView
self.cluster = cluster
self.position = QtCore.QPointF(x, y)
def __translateBound(self):
""" Translation of the boundary, so that it fits exactly around the figure"""
self.boundary.setLeft(self.boundary.left()+self.paintRect.center().x())
self.boundary.setRight(self.boundary.right()+self.paintRect.center().x())
self.boundary.setTop(-self.boundary.top()+self.paintRect.center().y())
self.boundary.setBottom(-self.boundary.bottom()+self.paintRect.center().y())
def shape(self):
""" Overridden function to set the boundary wherein the user can perform an action """
path = QtGui.QPainterPath()
path.addRect(self.boundary)
return path
def boundingRect(self):
""" Overridden function where a update area is determined for painting and returned """
return self.paintRect
def paint(self, painter, option, widget):
""" Visualisation of a clusteritem """
painter.setPen(QtGui.QColor(0,155,50))
self.textGraphic = QtGui.QGraphicsSimpleTextItem(str(list(self.cluster.variables)), self)
#self.textGraphic.translate(x,y)
self.paintRect = self.textGraphic.boundingRect()
#self.paintRect.translate(x,y)
self.translate(x,y)
def boundingRect(self):
""" Overridden function where a update area is determined for painting and returned """
return self.paintRect
def paint(self, painter, option, widget):
""" Visualisation of a clusteritem """
painter.setPen(QtGui.QColor(0,155,50))
if self.flag != None:
if self.flag == GeometricCluster.OK:
painter.setBrush(QtGui.QBrush(self.compositionView.wellConstrainedColor))
elif self.flag == GeometricCluster.I_UNDER or self.flag == GeometricCluster.S_UNDER:
painter.setBrush(QtGui.QBrush(self.compositionView.underConstrainedColor))
elif self.flag == GeometricCluster.I_OVER or self.flag == GeometricCluster.S_OVER:
painter.setBrush(QtGui.QBrush(self.compositionView.overConstrainedColor))
elif self.flag == GeometricCluster.UNSOLVED:
painter.setBrush(QtGui.QBrush(self.compositionView.unsolvedColor))
painter.drawPie(self.paintRect, self.startAngle, self.spanAngle)
def setInfoOverlay(self):
constrInfo = QtCore.QString("")
if self.flag == GeometricCluster.OK:
constrInfo = QtCore.QString("Well-Constrained\n")
elif self.flag == GeometricCluster.I_UNDER:
constrInfo = QtCore.QString("Inc. Underconstrained\n")
elif self.flag == GeometricCluster.S_UNDER:
constrInfo = QtCore.QString("Struct. Underconstrained\n")
elif self.flag == GeometricCluster.I_OVER:
constrInfo = QtCore.QString("Inc. Overconstrained\n")
elif self.flag == GeometricCluster.S_OVER:
constrInfo = QtCore.QString("Struct. Overconstrained\n")
elif self.flag == GeometricCluster.UNSOLVED:
constrInfo = QtCore.QString("Unsolved\n")
constrInfo.append("Points: ")
for point in self.variables:
pointObject = self.compositionView.prototypeManager.getObjectByKey(point)
if pointObject != None:
constrInfo.append(pointObject.name)
if point != self.variables[-1]:
constrInfo.append(", ")
self.compositionView.infoOverlay.infoText = constrInfo
#painter.setBrush(QtCore.Qt.NoBrush)
#painter.drawRect(self.bound)
def mousePressEvent(self, event):
""" Handling the mouse press, where the cluster (visualisation) and tree can be updated
Parameters:
event - pressed mousebutton
"""
if event.button() == QtCore.Qt.LeftButton:
self.updateCluster()
self.updateBound()
self.compositionView.updateTree()
elif event.button() == QtCore.Qt.RightButton:
if not self.clusterActive:
self.permanentCluster()
self.clusterActive = True
self.fixGraphic.show()
self.compositionView.stateChange(self.identifier, True)
else:
self.compositionView.prototypeManager.removeClusterObjects([self.permCluster], True, True)
self.clusterActive = False
self.fixGraphic.hide()
self.compositionView.stateChange(self.identifier, False)
self.permCluster = None
self.compositionView.prototypeManager.setObjectVisibilityByClusters()
self.compositionView.updateViewports()
def hoverEnterEvent(self, event):
self.setZValue(2)
self.setInfoOverlay()
self.compositionView.infoOverlay.setPosition(event.scenePos())
self.compositionView.infoOverlay.show()
if not self.clusterActive:
self.compositionView.prototypeManager.selectObjectsByKeys(self.variables)
self.highlightCluster()
self.compositionView.update()
self.compositionView.updateViewports()
def hoverMoveEvent(self, event):
self.overlayPosition = self.compositionView.ui.graphicsView.mapFromScene(event.scenePos())
self.compositionView.infoOverlay.setPosition(event.scenePos())
self.compositionView.updateConnections()
self.compositionView.update()
def hoverLeaveEvent(self, event):
self.setZValue(0)
self.compositionView.infoOverlay.infoText = ""
self.compositionView.infoOverlay.hide()
self.compositionView.infoOverlay.update()
if not self.clusterActive:
self.compositionView.prototypeManager.deselectAllObjects()
self.compositionView.prototypeManager.removeClusterObjects([self.clusterHighlight], True, False)
self.compositionView.updateViewports()
def updateCluster(self):
""" Cluster update, where the cluster is (un-)collapsed depending on the state of the cluster, to visualise a certain part of the tree """
if self.canCollapse:
if self.isCollapsed:
self.isCollapsed = False
self.showChildren()
height = self.paintRect.height()*0.5
width = self.paintRect.width()*0.5
height2 = self.paintRect.height()
if self.compositionView.tree.orientation == TreeOrientation.TOP:
self.paintRect.setTop(self.paintRect.top() + height )
self.paintRect.setBottom(self.paintRect.bottom() + height)
elif self.compositionView.tree.orientation == TreeOrientation.BOTTOM:
self.paintRect.setTop(self.paintRect.top()- height )
self.paintRect.setBottom(self.paintRect.bottom() - height)
elif self.compositionView.tree.orientation == TreeOrientation.LEFT:
self.paintRect.setLeft(self.paintRect.left() + width)
self.paintRect.setRight(self.paintRect.right() + width)
elif self.compositionView.tree.orientation == TreeOrientation.RIGHT:
self.paintRect.setLeft(self.paintRect.left() - width)
self.paintRect.setRight(self.paintRect.right() - width)
else:
self.isCollapsed = True
self.showChildren()
height = self.paintRect.height()*0.5
width = self.paintRect.width()*0.5
height2 = self.paintRect.height()
if self.compositionView.tree.orientation == TreeOrientation.TOP:
self.paintRect.setTop(self.paintRect.top() - height)
self.paintRect.setBottom(self.paintRect.bottom() - height)
elif self.compositionView.tree.orientation == TreeOrientation.BOTTOM:
self.paintRect.setTop(self.paintRect.top() + height)
self.paintRect.setBottom(self.paintRect.bottom() + height)
elif self.compositionView.tree.orientation == TreeOrientation.LEFT:
self.paintRect.setLeft(self.paintRect.left() - width)
self.paintRect.setRight(self.paintRect.right() - width)
elif self.compositionView.tree.orientation == TreeOrientation.RIGHT:
self.paintRect.setLeft(self.paintRect.left() + width)
self.paintRect.setRight(self.paintRect.right() + width)
if self.compositionView.tree.orientation == TreeOrientation.LEFT or self.compositionView.tree.orientation == TreeOrientation.RIGHT:
self.startAngle = self.startAngle + 180 * 16
else:
self.startAngle = -self.startAngle
self.spanAngle = -self.spanAngle
def highlightCluster(self):
if self.clusterHighlight != None:
if self.clusterHighlight.temporary:
self.compositionView.prototypeManager.addClusterObject(self.clusterHighlight)
self.clusterHighlight.selected = True
else:
self.clusterHighlight = self.compositionView.prototypeManager.selectClusterObjectByKeys(self.variables)
if self.clusterHighlight == None:
self.clusterHighlight = self.compositionView.prototypeManager.createCluster(self.variables)
if self.clusterHighlight != None:
self.clusterHighlight.temporary = True
if self.clusterHighlight != None:
self.clusterHighlight.selected = True
def permanentCluster(self):
if self.permCluster == None:
self.permCluster = self.compositionView.prototypeManager.createCluster(self.variables, self.flag)
self.permCluster.temporary = True
self.permCluster.fixed = True
self.compositionView.prototypeManager.setObjectVisibilityByClusters()
else:
self.compositionView.prototypeManager.addClusterObject(self.permCluster)
self.permCluster.selected = False
def showChildren(self):
""" Show the children of this node """
if self.isCollapsed or (self.isVisible()==False):
for child in self.children:
child.hide()
child.showChildren()
if child.clusterActive:
child.fixGraphic.hide()
else:
for child in self.children:
child.show()
child.showChildren()
if child.clusterActive:
child.fixGraphic.show()
else:
child.fixGraphic.hide()
def collapseFromResult(self):
if self.flag == GeometricCluster.I_UNDER or self.flag == GeometricCluster.S_UNDER or self.flag == GeometricCluster.I_OVER or self.flag == GeometricCluster.S_OVER or self.flag == GeometricCluster.UNSOLVED:
return True
else:
return False
def collapse(self):
if not self.isCollapsed:
self.updateCluster()
self.updateBound()
def expand(self):
if self.isCollapsed:
self.updateCluster()
self.updateBound()
class CVPoint(QtGui.QGraphicsItem, Node):
""" Visualisation of the leaves of the 'leaf' clusters in the tree """
def __init__(self, compView, parentNode, id, parent=None):
QtGui.QGraphicsItem.__init__(self, parent)
Node.__init__(self, parentNode)
self.compositionView = compView
self.setFlags(QtGui.QGraphicsItem.ItemIsSelectable)
self.setAcceptsHoverEvents(True)
self.startAngle = 0
self.spanAngle = 0
self.paintRect = QtCore.QRectF(0, 0, self.width/2, self.height/2)
self.fixGraphic = QtGui.QGraphicsSimpleTextItem("F", self)
self.fixGraphic.hide()
self.bezierCurve = None
self.flag = None
self.prtRef = None
self.boundary = self.paintRect
self.clusterHighlight = None
self.permCluster = None
self.clusterActive = False
self.identifier = id
def paint(self, painter, option, widget):
painter.setPen(QtGui.QColor(0,155,50))
painter.setBrush(QtGui.QBrush(QtGui.QColor(0,155,50)))
painter.drawEllipse(self.paintRect)
def setInfoOverlay(self):
constrInfo = QtCore.QString("Points \n")
if self.prtRef != None:
constrInfo += "Name: " + self.prtRef.name + "\n"
constrInfo += "Position: (" + str(round(self.prtRef.position[0],2)) + " , " + str(round(self.prtRef.position[1])) + " , " + str(round(self.prtRef.position[2])) + ")"
self.compositionView.infoOverlay.infoText = constrInfo
def mousePressEvent(self, event):
""" Handling the mouse press, where the cluster (visualisation) is handled
Parameters:
event - pressed mousebutton
"""
if event.button() == QtCore.Qt.RightButton:
if not self.clusterActive:
self.permanentCluster()
self.clusterActive = True
self.fixGraphic.show()
self.compositionView.stateChange(self.identifier, True)
else:
self.compositionView.prototypeManager.removeClusterObjects([self.permCluster], True, True)
self.clusterActive = False
self.permCluster = None
self.fixGraphic.hide()
self.compositionView.stateChange(self.identifier, False)
self.compositionView.prototypeManager.setObjectVisibilityByClusters()
self.compositionView.updateViewports()
def hoverEnterEvent(self, event):
self.setZValue(2)
self.setInfoOverlay()
self.compositionView.infoOverlay.setPosition(event.scenePos())
self.compositionView.infoOverlay.show()
if not self.clusterActive:
self.compositionView.prototypeManager.selectObject(self.prtRef)
self.highlightCluster()
self.compositionView.update()
self.compositionView.updateViewports()
def hoverMoveEvent(self, event):
self.compositionView.infoOverlay.setPosition(event.scenePos())
self.compositionView.update()
def hoverLeaveEvent(self, event):
self.setZValue(0)
self.compositionView.infoOverlay.infoText = ""
self.compositionView.infoOverlay.hide()
self.compositionView.infoOverlay.update()
if not self.clusterActive:
self.compositionView.prototypeManager.deselectAllObjects()
self.compositionView.prototypeManager.removeClusterObjects([self.clusterHighlight], True)
self.compositionView.updateViewports()
def highlightCluster(self):
if self.clusterHighlight != None:
if self.clusterHighlight.temporary:
self.compositionView.prototypeManager.addClusterObject(self.clusterHighlight)
self.clusterHighlight.selected = True
else:
self.clusterHighlight = self.compositionView.prototypeManager.selectClusterObjectByKeys([self.prtRef.key])
if self.clusterHighlight == None:
self.clusterHighlight = self.compositionView.prototypeManager.createCluster([self.prtRef.key])
if self.clusterHighlight != None:
self.clusterHighlight.temporary = True
if self.clusterHighlight != None:
self.clusterHighlight.selected = True
def permanentCluster(self):
if self.permCluster == None:
self.permCluster = self.compositionView.prototypeManager.createCluster([self.prtRef.key])
self.permCluster.temporary = True
self.permCluster.fixed = True
self.compositionView.prototypeManager.setObjectVisibilityByClusters()
else:
self.compositionView.prototypeManager.addClusterObject(self.permCluster)
self.permCluster.selected = False
def boundingRect(self):
return self.paintRect
def setWidthAndHeight(self, width, height):
self.width = width
self.height = height
self.paintRect.setWidth(width)
self.paintRect.setHeight(height)
def showChildren(self):
""" Show the children of this node """
if self.isCollapsed or (self.isVisible()==False):
for child in self.children:
child.hide()
child.showChildren()
else:
for child in self.children:
child.show()
child.showChildren()
def collapse(self):
self.isCollapsed = True
def expand(self):
self.isCollapsed = False
class CVInfoOverlay(QtGui.QGraphicsItem):
def __init__(self, compView, parent=None):
QtGui.QGraphicsItem.__init__(self, parent)
self.node = None
self.compositionView = compView
self.infoText = QtCore.QString("")
self.setZValue(3)
self.infoOverlay = QtCore.QRectF(0, 0, 140, 50)
self.overlayPosition = QtCore.QPointF()
self.scenePosition = QtCore.QPointF()
self.overlayBGColor = QtGui.QColor(204, 251, 255, 200)
self.overlayLineColor = QtGui.QColor(33, 116, 154)
self.overlayTextColor = QtGui.QColor(0, 0, 0)
def paint(self, painter, option, widget):
painter.save()
painter.resetMatrix()
painter.translate(self.overlayPosition)
painter.translate(10.0, 10.0)
painter.setPen(self.overlayLineColor)
painter.setBrush(self.overlayBGColor)
painter.drawRect(self.infoOverlay)
infoFont = QtGui.QFont("Arial", 7)
infoFont.setStyleStrategy(QtGui.QFont.ForceOutline)
painter.setFont(infoFont)
painter.setRenderHint(QtGui.QPainter.TextAntialiasing, False)
painter.setPen(self.overlayTextColor)
textRect = QtCore.QRect(self.infoOverlay.left()+4, self.infoOverlay.top(), self.infoOverlay.width()-3, self.infoOverlay.height()-3)
painter.drawText(textRect, QtCore.Qt.AlignLeft|QtCore.Qt.TextWordWrap, self.infoText)
painter.restore()
def setPosition(self, position):
self.scenePosition = position
self.overlayPosition = self.compositionView.ui.graphicsView.mapFromScene(position)
def boundingRect(self):
check = QtCore.QRectF(self.infoOverlay)
return check
if self.cluster.flag != None:
if self.cluster.flag == GeometricCluster.OK:
painter.setBrush(QtGui.QBrush(self.compositionView.wellConstrainedColor))
elif self.cluster.flag == GeometricCluster.I_UNDER or self.cluster.flag == GeometricCluster.S_UNDER:
painter.setBrush(QtGui.QBrush(self.compositionView.underConstrainedColor))
elif self.cluster.flag == GeometricCluster.I_OVER or self.cluster.flag == GeometricCluster.S_OVER:
painter.setBrush(QtGui.QBrush(self.compositionView.overConstrainedColor))
elif self.cluster.flag == GeometricCluster.UNSOLVED:
painter.setBrush(QtGui.QBrush(self.compositionView.unsolvedColor))
painter.drawRect(self.paintRect)
class CVConnection(QtGui.QGraphicsItem):
""" Visualisation of the connections between the clusters, where two types of visualisation can be chosen: Bezier(default) and Lines """
def __init__(self, compView, nodeFrom , nodeTo, parent=None):
QtGui.QGraphicsItem.__init__(self, parent)
self.settings = Settings()
self.compositionView = compView
self.nodeFrom = nodeFrom
self.nodeTo = nodeTo
self.connectType = self.settings.dvData.treeConnection
#self.boundRect = QtCore.QRectF(0.0, 0.0, 0.0, 0.0)
self.beziercurve = None
self.paintRect = QtCore.QRectF(0, 0, 0, 0)
self.setZValue(1)
def paint(self, painter, option, widget):
""" Visualisation of the connection between two nodes """
if self.nodeFrom != None and self.nodeTo != None:
painter.setPen(QtGui.QColor(0,0,0))
diffPosExt = self.paintRect
endPoint = self.determineEndpoint(diffPosExt)
""" Visualisation of the connections between the clusters, where two types of visualisation can be chosen: Bezier(default) and Lines """
def __init__(self, compView, nodeFrom , nodeTo):
QtGui.QGraphicsItem.__init__(self)
self.settings = Settings()
self.compositionView = compView
self.nodeFrom = nodeFrom
self.nodeTo = nodeTo
self.beziercurve = None
self.paintRect = None
self.setZValue(1)
self.determinePath()
if self.connectType == ConnectionType.BEZIER:
""" display a bezier curve as connection """
self.beziercurve = QtGui.QPainterPath()
if self.compositionView.tree.orientation == TreeOrientation.TOP:
self.beziercurve.moveTo(diffPosExt.x(), diffPosExt.y())
firstPoint = QtCore.QPointF(diffPosExt.x(), diffPosExt.height()*0.5)
elif self.compositionView.tree.orientation == TreeOrientation.BOTTOM:
self.beziercurve.moveTo(diffPosExt.x(), diffPosExt.bottom())
firstPoint = QtCore.QPointF(diffPosExt.x(), -diffPosExt.height()*0.5 + self.nodeTo.paintRect.height())
elif self.compositionView.tree.orientation == TreeOrientation.LEFT:
self.beziercurve.moveTo(diffPosExt.x(), diffPosExt.y())
firstPoint = QtCore.QPointF(diffPosExt.width()*0.5, diffPosExt.y())
elif self.compositionView.tree.orientation == TreeOrientation.RIGHT:
self.beziercurve.moveTo(diffPosExt.x(), diffPosExt.y())
firstPoint = QtCore.QPointF(self.nodeTo.paintRect.width() + diffPosExt.width()*0.5,diffPosExt.y())
if self.compositionView.tree.orientation == TreeOrientation.TOP:
secondPoint = QtCore.QPointF(diffPosExt.right(),diffPosExt.height()*0.5)
elif self.compositionView.tree.orientation == TreeOrientation.BOTTOM:
secondPoint = QtCore.QPointF(diffPosExt.right(), self.nodeTo.paintRect.height() - diffPosExt.height()*0.5)
elif self.compositionView.tree.orientation == TreeOrientation.LEFT:
secondPoint = QtCore.QPointF(diffPosExt.width()*0.5, diffPosExt.bottom())
elif self.compositionView.tree.orientation == TreeOrientation.RIGHT:
secondPoint = QtCore.QPointF(self.nodeTo.paintRect.width() + diffPosExt.width()*0.5, diffPosExt.bottom())
self.beziercurve.cubicTo(firstPoint, secondPoint, endPoint)
painter.drawPath(self.beziercurve)
elif self.connectType == ConnectionType.LINES:
""" draw a straight line """
if self.compositionView.tree.orientation == TreeOrientation.TOP:
painter.drawLine(QtCore.QPointF(self.nodeTo.paintRect.width()*0.5, 0.0), QtCore.QPointF(endPoint.x(), endPoint.y()))
elif self.compositionView.tree.orientation == TreeOrientation.BOTTOM:
painter.drawLine(QtCore.QPointF(self.nodeTo.paintRect.width()*0.5, self.nodeTo.paintRect.height()), QtCore.QPointF(endPoint.x(), endPoint.y()))
elif self.compositionView.tree.orientation == TreeOrientation.LEFT:
painter.drawLine(QtCore.QPointF(0.0, self.nodeTo.paintRect.height()*0.5), QtCore.QPointF(endPoint.x(), endPoint.y()))
elif self.compositionView.tree.orientation == TreeOrientation.RIGHT:
painter.drawLine(QtCore.QPointF(self.nodeTo.paintRect.width(), self.nodeTo.paintRect.height()*0.5), QtCore.QPointF(endPoint.x(), endPoint.y()))
def areaBetweenNodes(self):
diffPos = self.nodeTo.position - self.nodeFrom.position
area = QtCore.QRectF(0.0, 0.0, 0.0 , 0.0)
if self.compositionView.tree.orientation == TreeOrientation.TOP:
area.setX(self.nodeTo.paintRect.width()*0.5)
area.setY(0.0)
area.setRight(self.nodeFrom.paintRect.width()*0.5 - diffPos.x())
area.setBottom(self.nodeTo.boundary.height()-diffPos.y())
elif self.compositionView.tree.orientation == TreeOrientation.BOTTOM:
area.setX(self.nodeTo.paintRect.width()*0.5)
area.setY(-diffPos.y()+self.nodeFrom.boundary.height())
area.setRight(-diffPos.x()+self.nodeFrom.paintRect.width()*0.5)
area.setBottom(self.nodeTo.paintRect.height())
elif self.compositionView.tree.orientation == TreeOrientation.LEFT:
area.setX(0.0)
area.setY(self.nodeTo.paintRect.height()*0.5)
area.setRight(-diffPos.x()+self.nodeFrom.boundary.width())
area.setBottom(-diffPos.y() + self.nodeFrom.paintRect.height()*0.5)
elif self.compositionView.tree.orientation == TreeOrientation.RIGHT:
area.setX(self.nodeTo.paintRect.width())
area.setY(self.nodeTo.paintRect.height()*0.5)
area.setRight(-diffPos.x() + self.nodeFrom.paintRect.width()*0.5)
area.setBottom(-diffPos.y() + self.nodeFrom.paintRect.height()*0.5)
return area
def determineEndpoint(self, area):
endPoint = QtCore.QPointF(0.0, 0.0)
if self.compositionView.tree.orientation == TreeOrientation.TOP:
endPoint.setX(area.right())
endPoint.setY(area.height())
elif self.compositionView.tree.orientation == TreeOrientation.BOTTOM:
endPoint.setX(area.right())
endPoint.setY(area.y())
elif self.compositionView.tree.orientation == TreeOrientation.LEFT:
endPoint.setX(area.right())
endPoint.setY(area.bottom())
elif self.compositionView.tree.orientation == TreeOrientation.RIGHT:
endPoint.setX(area.right())
endPoint.setY(area.bottom())
return endPoint
def boundingRect(self):
""" Overridden function where a update area is determined for painting and returned """
self.paintRect = self.areaBetweenNodes()
return self.paintRect
def determinePath(self):
if self.nodeFrom != None and self.nodeTo != None:
self.beziercurve = QtGui.QPainterPath()
x1 = self.nodeFrom.position.x() + self.nodeFrom.paintRect.width()/2
x2 = self.nodeTo.position.x() + self.nodeTo.paintRect.width()/2
y1 = self.nodeFrom.position.y()
y2 = self.nodeTo.position.y() + self.nodeFrom.paintRect.height()
p1 = QtCore.QPointF(x1,y1)
p2 = QtCore.QPointF(x1,y1+(y2-y1)/2)
p3 = QtCore.QPointF(x2,y1+(y2-y1)/2)
p4 = QtCore.QPointF(x2,y2)
self.beziercurve.moveTo(p1)
self.beziercurve.cubicTo(p2,p3,p4)
def paint(self, painter, option, widget):
""" Visualisation of the connection between two nodes """
if self.beziercurve:
painter.drawPath(self.beziercurve)
def boundingRect(self):
""" Overridden function where a update area is determined for painting and returned """
return self.beziercurve.boundingRect()

View File

@ -1,4 +1,4 @@
import preferencesDlg, compositionView
import preferencesDlg, decompositionView
from includes import *
from viewportManager import *
from prototypeObjects import PrototypeManager
@ -191,7 +191,7 @@ class Ui_MainWindow(QtGui.QMainWindow):
self.addDockWidget(QtCore.Qt.RightDockWidgetArea, self.dock)
def createDecompositionView(self):
self.compositionView = CompositionView(None, self.viewportManager, ViewportType.DECOMPOSITION ,PrototypeManager())
self.compositionView = DecompositionView(None, self.viewportManager, ViewportType.DECOMPOSITION ,PrototypeManager())
def createSolutionView(self):
self.solutionView = SolutionView(self, self.viewportManager, ViewportType.SOLUTION ,PrototypeManager())

View File

@ -6,7 +6,7 @@ from parameters import Settings
class SolutionView(QtGui.QDialog):
""" Visualises the solution from the constraint solver. """
def __init__(self, mainWindow, viewportMngr, vpType, prototypeMngr, isViewport=False, parent=None):
""" Initialization of the CompositionView class
""" Initialization of the SolutionView class
Parameters:
mainWindow - main window of the application, necessary for updating

View File

@ -1,5 +1,5 @@
from includes import *
from compositionView import CompositionView
from decompositionView import DecompositionView
from solutionView import SolutionView
from prototypeObjects import PrototypeManager
from glViewer import *
@ -153,7 +153,7 @@ class Viewport(QtGui.QScrollArea):
elif viewportName == "Perspective":
self.glViewport = GLViewport(self, ViewportType.PERSPECTIVE, None, QtOpenGL.QGLFormat(QtOpenGL.QGL.SampleBuffers))
elif viewportName == "Decomposition":
self.glViewport = CompositionView(self, self.viewportManager, ViewportType.DECOMPOSITION, PrototypeManager()) #self.getMainWindow().compositionView #
self.glViewport = DecompositionView(self, self.viewportManager, ViewportType.DECOMPOSITION, PrototypeManager()) #self.getMainWindow().compositionView #
elif viewportName == "Solution":
self.solutionView = SolutionView(self.getMainWindow(), self.viewportManager, ViewportType.SOLUTION, PrototypeManager(), True)
self.glViewport = self.solutionView.solutionWidget