示例#1
0
    def __init__(self,
                 mainWindow,
                 viewportMngr,
                 vpType,
                 prototypeMngr,
                 isViewport=False,
                 parent=None):
        """ Initialization of the CompositionView class
			
		Parameters:
			mainWindow - main window of the application, necessary for updating
			viewportMngr - the manager of the viewports where the composition view can reside in
			vpType - type of this view
			prototypeMngr - the manager of the prototypes is used to obtain the results of the solver
			parent - parent of this dialog
		"""
        QtGui.QDialog.__init__(self, parent)
        self.mainWindow = mainWindow
        self.prototypeManager = prototypeMngr
        self.viewportManager = viewportMngr
        self.setWindowFlags(QtCore.Qt.Window)
        self.ui = Ui_SolutionView()
        self.ui.setupUi(self)
        self.settings = Settings()

        self.solutionWidget = SolutionGLViewport(
            self, ViewportType.SOLUTION, None,
            QtOpenGL.QGLFormat(QtOpenGL.QGL.SampleBuffers), self)
        self.solutionWidget.gridVisible = False
        self.ui.vboxlayout.addWidget(self.solutionWidget, 200)

        self.updateAction = UpdateActionCommand(self.getMainWindow())
        self.isViewport = isViewport
        self.solutionObjects = []

        if not self.isViewport:
            self.moveActive = False
            self.zoomActive = False
            self.rotateActive = False
            self.createTriggers()
        else:
            self.removeInterfaceItems()

        self.createSolution()
示例#2
0
	def __init__(self, mainWindow, viewportMngr, vpType, prototypeMngr, isViewport=False, parent=None):
		""" Initialization of the SolutionView class
			
		Parameters:
			mainWindow - main window of the application, necessary for updating
			viewportMngr - the manager of the viewports where the composition view can reside in
			vpType - type of this view
			prototypeMngr - the manager of the prototypes is used to obtain the results of the solver
			parent - parent of this dialog
		"""
		QtGui.QDialog.__init__(self, parent)
		self.mainWindow = mainWindow
		self.prototypeManager = prototypeMngr
		self.viewportManager = viewportMngr
		self.setWindowFlags(QtCore.Qt.Window)
		self.ui = Ui_SolutionView()
		self.ui.setupUi(self)
		self.settings = Settings()

		self.solutionWidget = SolutionGLViewport(self, ViewportType.SOLUTION, None, QtOpenGL.QGLFormat(QtOpenGL.QGL.SampleBuffers), self)
		self.solutionWidget.gridVisible = False
		self.ui.vboxlayout.addWidget(self.solutionWidget, 200)
		
		self.updateAction = UpdateActionCommand(self.getMainWindow())
		self.isViewport = isViewport
		self.solutionObjects = []
		
		if not self.isViewport:
			self.moveActive = False
			self.zoomActive = False
			self.rotateActive = False
			self.createTriggers()
		else:
			self.removeInterfaceItems()
			
		self.createSolution()
class SolutionView(QtWidgets.QDialog):
    """ Visualises the solution from the constraint solver. """

    def __init__(self, mainWindow, viewportMngr, vpType, prototypeMngr,
                 isViewport=False, parent=None):
        """ Initialization of the CompositionView class
            
        Parameters:
            mainWindow - main window of the application, necessary for updating
            viewportMngr - the manager of the viewports where the composition view can reside in
            vpType - type of this view
            prototypeMngr - the manager of the prototypes is used to obtain the results of the solver
            parent - parent of this dialog
        """
        QtWidgets.QDialog.__init__(self, parent)
        self.mainWindow = mainWindow
        self.prototypeManager = prototypeMngr
        self.viewportManager = viewportMngr
        self.setWindowFlags(QtCore.Qt.Window)
        self.ui = Ui_SolutionView()
        self.ui.setupUi(self)
        self.settings = Settings()

        self.solutionWidget = SolutionGLViewport(self, ViewportType.SOLUTION,
                                                 None, QtOpenGL.QGLFormat(
                QtOpenGL.QGL.SampleBuffers), self)
        self.solutionWidget.gridVisible = False
        self.ui.vboxlayout.addWidget(self.solutionWidget, 200)

        self.updateAction = UpdateActionCommand(self.getMainWindow())
        self.isViewport = isViewport
        self.solutionObjects = []

        if not self.isViewport:
            self.moveActive = False
            self.zoomActive = False
            self.rotateActive = False
            self.createTriggers()
        else:
            self.removeInterfaceItems()

        self.createSolution()

    def createTriggers(self):
        """ Triggers for the buttons in the Solution View """
        # QtCore.QObject.connect(self.ui.moveButton,
        #                        QtCore.SIGNAL("clicked(bool)"),
        #                        self.setMoveActive)
        self.ui.moveButton.clicked.connect(self.setMoveActive)
        # QtCore.QObject.connect(self.ui.rotateButton,
        #                        QtCore.SIGNAL("clicked(bool)"),
        #                        self.setRotateActive)
        self.ui.rotateButton.clicked.connect(self.setRotateActive)
        # QtCore.QObject.connect(self.ui.zoomButton,
        #                        QtCore.SIGNAL("clicked(bool)"),
        #                        self.setZoomActive)
        self.ui.zoomButton.clicked.connect(self.setZoomActive)
        # QtCore.QObject.connect(self.ui.syncButton,
        #                        QtCore.SIGNAL("clicked(bool)"),
        #                        self.synchronise)
        self.ui.syncButton.clicked.connect(self.synchronise)
        #
        # QtCore.QObject.connect(self.settings.svData,
        #                        QtCore.SIGNAL("pointSizeChanged"),
        #                        self.updateSize)
        self.settings.svData.pointSizeChanged.connect(self.updateSize)
        # QtCore.QObject.connect(self.settings.svData,
        #                        QtCore.SIGNAL("fPointSizeChanged"),
        #                        self.updateSize)
        self.settings.svData.fPointSizeChanged.connect(self.updateSize)
        # QtCore.QObject.connect(self.settings.svData,
        #                        QtCore.SIGNAL("lineSizeChanged"),
        #                        self.updateSize)
        self.settings.svData.lineSizeChanged.connect(self.updateSize)
        # QtCore.QObject.connect(self.settings.svData,
        #                        QtCore.SIGNAL("distanceSizeChanged"),
        #                        self.updateSize)
        self.settings.svData.distanceSizeChanged.connect(self.updateSize)
        # QtCore.QObject.connect(self.settings.svData,
        #                        QtCore.SIGNAL("pointColorChanged"),
        #                        self.updateColor)
        self.settings.svData.pointColorChanged.connect(self.updateColor)
        # QtCore.QObject.connect(self.settings.svData,
        #                        QtCore.SIGNAL("fPointColorChanged"),
        #                        self.updateColor)
        self.settings.svData.fPointColorChanged.connect(self.updateColor)
        # QtCore.QObject.connect(self.settings.svData,
        #                        QtCore.SIGNAL("lineColorChanged"),
        #                        self.updateColor)
        self.settings.svData.lineColorChanged.connect(self.updateColor)
        # QtCore.QObject.connect(self.settings.svData,
        #                        QtCore.SIGNAL("angleColorChanged"),
        #                        self.updateColor)
        self.settings.svData.angleColorChanged.connect(self.updateColor)
        # QtCore.QObject.connect(self.settings.svData,
        #                        QtCore.SIGNAL("selectionColorChanged"),
        #                        self.updateColor)
        self.settings.svData.selectionColorChanged.connect(self.updateColor)
        # QtCore.QObject.connect(self.settings.svData,
        #                        QtCore.SIGNAL("distanceColorChanged"),
        #                        self.updateColor)
        self.settings.svData.distanceColorChanged.connect(self.updateColor)
        #
        # QtCore.QObject.connect(self.settings.svData,
        #                        QtCore.SIGNAL("pointVisChanged"),
        #                        self.updateVisibility)
        self.settings.svData.pointVisChanged.connect(self.updateVisibility)
        # QtCore.QObject.connect(self.settings.svData,
        #                        QtCore.SIGNAL("fpointVisChanged"),
        #                        self.updateVisibility)
        self.settings.svData.fpointVisChanged.connect(self.updateVisibility)
        # QtCore.QObject.connect(self.settings.svData,
        #                        QtCore.SIGNAL("lineVisChanged"),
        #                        self.updateVisibility)
        self.settings.svData.lineVisChanged.connect(self.updateVisibility)
        # QtCore.QObject.connect(self.settings.svData,
        #                        QtCore.SIGNAL("angleVisChanged"),
        #                        self.updateVisibility)
        self.settings.svData.angleVisChanged.connect(self.updateVisibility)
        # QtCore.QObject.connect(self.settings.svData,
        #                        QtCore.SIGNAL("distanceVisChanged"),
        #                        self.updateVisibility)
        self.settings.svData.distanceVisChanged.connect(self.updateVisibility)

    def removeInterfaceItems(self):
        """ Removes the standard interface buttons to control
        the camera etc. """
        self.ui.moveButton.hide()
        self.ui.rotateButton.hide()
        self.ui.zoomButton.hide()
        self.ui.vboxlayout.removeItem(self.ui.hboxlayout)

    def setMoveActive(self, active):
        """ Set the move button as active button and inform the camera the
        translation action is active
        
        Paramaters:
            active - set the state of the camera, in this case for translation
        """
        self.moveActive = active
        self.updateAction.execute(self.solutionWidget)
        self.solutionWidget.cameraHandler.setActiveMouseaction(
            MouseAction.TRANSLATE)

    def setZoomActive(self, active):
        """ Set the zoom button as active button and inform the camera the zoom action is active
        
        Paramaters:
            active - set the state of the camera, in this case for zooming
        """
        self.zoomActive = active
        self.updateAction.execute(self.solutionWidget)
        self.solutionWidget.cameraHandler.setActiveMouseaction(MouseAction.ZOOM)

    def setRotateActive(self, active):
        """ Set the rotation button as active button and inform the camera the rotation action is active
        
        Paramaters:
            active - set the state of the camera, in this case for rotation
        """
        self.rotateActive = active
        self.updateAction.execute(self.solutionWidget)
        self.solutionWidget.cameraHandler.setActiveMouseaction(
            MouseAction.ROTATE)

    def updateSize(self):
        for solObject in self.solutionObjects:
            if solObject.objType == ObjectType.POINT:
                solObject.radius = self.settings.svData.pointRadius
            elif solObject.objType == ObjectType.FIXED_POINT:
                solObject.radius = self.settings.svData.fPointRadius
            elif solObject.objType == ObjectType.DISTANCE_HELPER:
                solObject.radius = self.settings.svData.lineRadius
            elif solObject.objType == ObjectType.DISTANCE_CONSTRAINT:
                solObject.radius = self.settings.svData.distanceRadius

    def updateColor(self):
        for solObject in self.solutionObjects:
            if solObject.objType == ObjectType.POINT:
                solObject.color = self.settings.svData.pointColor
            elif solObject.objType == ObjectType.FIXED_POINT:
                solObject.color = self.settings.svData.fPointColor
            elif solObject.objType == ObjectType.DISTANCE_HELPER:
                solObject.color = self.settings.svData.lineColor
            elif solObject.objType == ObjectType.DISTANCE_CONSTRAINT:
                solObject.color = self.settings.svData.distanceColor
            elif solObject.objType == ObjectType.ANGLE_CONSTRAINT:
                solObject.color = self.settings.svData.angleColor

    def updateVisibility(self):
        for solObject in self.solutionObjects:
            if solObject.objType == ObjectType.POINT:
                solObject.isVisible = self.settings.svData.pointVisible
            elif solObject.objType == ObjectType.FIXED_POINT:
                solObject.isVisible = self.settings.svData.fPointVisible
            elif solObject.objType == ObjectType.DISTANCE_HELPER:
                solObject.isVisible = self.settings.svData.lineVisible
            elif solObject.objType == ObjectType.DISTANCE_CONSTRAINT:
                solObject.isVisible = self.settings.svData.distanceVisible
            elif solObject.objType == ObjectType.ANGLE_CONSTRAINT:
                solObject.isVisible = self.settings.svData.angleVisible

    def updateViewports(self):
        """ Update the general viewports """
        self.viewportManager.updateViewports()

    def isActive(self):
        if self.viewportManager.getActiveViewportType() == self:
            return True
        else:
            return False

    def getMainWindow(self):
        """ Return the main window object """
        return self.mainWindow

    def createSolution(self):
        """ Create objects for visualisation in the solution view, this action will typically take place, when the system of GCS is solved """
        del self.solutionObjects[:]
        if self.prototypeManager.result != None:
            if len(self.prototypeManager.result.solutions) > 0:
                solution = self.prototypeManager.result.solutions[0]
                for variable in self.prototypeManager.result.variables:
                    self.solutionObjects += [
                        Point(variable, Vec(solution[variable]), 5.0)]

                self.createDistanceConstraints()
                self.createAngleConstraints()
                self.createDistances()
        self.solutionWidget.update()

    def createDistanceConstraints(self):
        """ Create the distance constraints as visualisation between the nodes """
        distances = filter(
            lambda c: isinstance(c, geosolver.DistanceConstraint),
            self.prototypeManager.geoProblem.cg.constraints())
        for distance in distances:
            beginPoint = self.getSolutionPointByKey(distance._variables[0])
            endPoint = self.getSolutionPointByKey(distance._variables[1])
            distanceConstr = DistanceConstraint("", beginPoint, endPoint)
            distanceConstr.height = distance._value
            distanceConstr.update()
            self.solutionObjects += [distanceConstr]

    def createAngleConstraints(self):
        angles = filter(lambda c: isinstance(c, geosolver.AngleConstraint),
                        self.prototypeManager.geoProblem.cg.constraints())
        for angle in angles:
            beginPoint = self.getSolutionPointByKey(angle._variables[0])
            middlePoint = self.getSolutionPointByKey(angle._variables[1])
            endPoint = self.getSolutionPointByKey(angle._variables[2])
            angleConstr = AngleConstraint("", beginPoint, middlePoint, endPoint)
            angleConstr.realAngle = angle._value
            angleConstr.update()
            self.solutionObjects += [angleConstr]

    def createDistances(self):
        distances = filter(lambda x: x.objType == ObjectType.DISTANCE_HELPER,
                           self.prototypeManager.prtObjects)
        for distance in distances:
            solPointBegin = filter(lambda
                                       x: x.key == distance.pointBegin.key and x.objType == ObjectType.POINT,
                                   self.solutionObjects)
            solPointEnd = filter(lambda
                                     x: x.key == distance.pointEnd.key and x.objType == ObjectType.POINT,
                                 self.solutionObjects)
            solDistance = Distance("", solPointBegin[0], solPointEnd[0])
            solDistance.update()
            self.solutionObjects += [solDistance]

    def synchronise(self):
        if self.prototypeManager.result != None:
            prtPoints = filter(lambda x: x.objType == ObjectType.POINT,
                               self.prototypeManager.prtObjects)
            solPoints = filter(lambda x: x.objType == ObjectType.POINT,
                               self.solutionObjects)
            for prtPoint in prtPoints:
                for solPoint in solPoints:
                    if prtPoint.key == solPoint.key:
                        prtPoint.setPosition(solPoint.position)
            self.prototypeManager.updateObjects()
            self.updateViewports()

    def getSolutionPointByKey(self, variable):
        """ Get the first point from the solution by a variable 
        
        Parameters:
            variable - variable which identifies the point which needs to be obtained
        
        Return:
            point - point from the solution object list
        """
        point = filter(lambda p: p.key == variable, self.solutionObjects)
        if point != None:
            return point[0]

    def drawObjects(self):
        """ Draw the objects in the Solution View """
        for solObj in self.solutionObjects:
            if solObj.isVisible:
                solObj.draw()
示例#4
0
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 SolutionView class
			
		Parameters:
			mainWindow - main window of the application, necessary for updating
			viewportMngr - the manager of the viewports where the composition view can reside in
			vpType - type of this view
			prototypeMngr - the manager of the prototypes is used to obtain the results of the solver
			parent - parent of this dialog
		"""
		QtGui.QDialog.__init__(self, parent)
		self.mainWindow = mainWindow
		self.prototypeManager = prototypeMngr
		self.viewportManager = viewportMngr
		self.setWindowFlags(QtCore.Qt.Window)
		self.ui = Ui_SolutionView()
		self.ui.setupUi(self)
		self.settings = Settings()

		self.solutionWidget = SolutionGLViewport(self, ViewportType.SOLUTION, None, QtOpenGL.QGLFormat(QtOpenGL.QGL.SampleBuffers), self)
		self.solutionWidget.gridVisible = False
		self.ui.vboxlayout.addWidget(self.solutionWidget, 200)
		
		self.updateAction = UpdateActionCommand(self.getMainWindow())
		self.isViewport = isViewport
		self.solutionObjects = []
		
		if not self.isViewport:
			self.moveActive = False
			self.zoomActive = False
			self.rotateActive = False
			self.createTriggers()
		else:
			self.removeInterfaceItems()
			
		self.createSolution()
	
	def createTriggers(self):
		""" Triggers for the buttons in the Solution View """
		QtCore.QObject.connect(self.ui.moveButton, QtCore.SIGNAL("clicked(bool)"), self.setMoveActive)
		QtCore.QObject.connect(self.ui.rotateButton, QtCore.SIGNAL("clicked(bool)"), self.setRotateActive)
		QtCore.QObject.connect(self.ui.zoomButton, QtCore.SIGNAL("clicked(bool)"), self.setZoomActive)
		QtCore.QObject.connect(self.ui.syncButton, QtCore.SIGNAL("clicked(bool)"), self.synchronise)
		
		QtCore.QObject.connect(self.settings.svData,QtCore.SIGNAL("pointSizeChanged"), self.updateSize)
		QtCore.QObject.connect(self.settings.svData,QtCore.SIGNAL("fPointSizeChanged"), self.updateSize)
		QtCore.QObject.connect(self.settings.svData,QtCore.SIGNAL("lineSizeChanged"), self.updateSize)
		QtCore.QObject.connect(self.settings.svData,QtCore.SIGNAL("distanceSizeChanged"), self.updateSize)
		QtCore.QObject.connect(self.settings.svData,QtCore.SIGNAL("pointColorChanged"), self.updateColor)
		QtCore.QObject.connect(self.settings.svData,QtCore.SIGNAL("fPointColorChanged"), self.updateColor)
		QtCore.QObject.connect(self.settings.svData,QtCore.SIGNAL("lineColorChanged"), self.updateColor)
		QtCore.QObject.connect(self.settings.svData,QtCore.SIGNAL("angleColorChanged"), self.updateColor)
		QtCore.QObject.connect(self.settings.svData,QtCore.SIGNAL("selectionColorChanged"), self.updateColor)
		QtCore.QObject.connect(self.settings.svData,QtCore.SIGNAL("distanceColorChanged"), self.updateColor)

		QtCore.QObject.connect(self.settings.svData,QtCore.SIGNAL("pointVisChanged"), self.updateVisibility)
		QtCore.QObject.connect(self.settings.svData,QtCore.SIGNAL("fpointVisChanged"), self.updateVisibility)
		QtCore.QObject.connect(self.settings.svData,QtCore.SIGNAL("lineVisChanged"), self.updateVisibility)
		QtCore.QObject.connect(self.settings.svData,QtCore.SIGNAL("angleVisChanged"), self.updateVisibility)
		QtCore.QObject.connect(self.settings.svData,QtCore.SIGNAL("distanceVisChanged"), self.updateVisibility)		

	def removeInterfaceItems(self):
		""" Removes the standard interface buttons to control the camera etc. """
		self.ui.moveButton.hide()
		self.ui.rotateButton.hide()
		self.ui.zoomButton.hide()
		self.ui.vboxlayout.removeItem(self.ui.hboxlayout)
	
	def setMoveActive(self, active):
		""" Set the move button as active button and inform the camera the translation action is active
		
		Paramaters:
			active - set the state of the camera, in this case for translation
		"""
		self.moveActive = active
		self.updateAction.execute(self.solutionWidget)
		self.solutionWidget.cameraHandler.setActiveMouseaction(MouseAction.TRANSLATE)

	def setZoomActive(self, active):
		""" Set the zoom button as active button and inform the camera the zoom action is active
		
		Paramaters:
			active - set the state of the camera, in this case for zooming
		"""
		self.zoomActive = active
		self.updateAction.execute(self.solutionWidget)
		self.solutionWidget.cameraHandler.setActiveMouseaction(MouseAction.ZOOM)

	def setRotateActive(self, active):
		""" Set the rotation button as active button and inform the camera the rotation action is active
		
		Paramaters:
			active - set the state of the camera, in this case for rotation
		"""
		self.rotateActive = active
		self.updateAction.execute(self.solutionWidget)
		self.solutionWidget.cameraHandler.setActiveMouseaction(MouseAction.ROTATE)

	def updateSize(self):
		for solObject in self.solutionObjects:
			if solObject.objType == ObjectType.POINT:
				solObject.radius = self.settings.svData.pointRadius
			elif solObject.objType == ObjectType.FIXED_POINT:
				solObject.radius = self.settings.svData.fPointRadius
			elif solObject.objType == ObjectType.DISTANCE_HELPER:
				solObject.radius = self.settings.svData.lineRadius
			elif solObject.objType == ObjectType.DISTANCE_CONSTRAINT:
				solObject.radius = self.settings.svData.distanceRadius
				
	def updateColor(self):
		for solObject in self.solutionObjects:
			if solObject.objType == ObjectType.POINT:
				solObject.color = self.settings.svData.pointColor
			elif solObject.objType == ObjectType.FIXED_POINT:
				solObject.color = self.settings.svData.fPointColor
			elif solObject.objType == ObjectType.DISTANCE_HELPER:
				solObject.color = self.settings.svData.lineColor
			elif solObject.objType == ObjectType.DISTANCE_CONSTRAINT:
				solObject.color = self.settings.svData.distanceColor
			elif solObject.objType == ObjectType.ANGLE_CONSTRAINT:
				solObject.color = self.settings.svData.angleColor

	def updateVisibility(self):
		for solObject in self.solutionObjects:
			if solObject.objType == ObjectType.POINT:
				solObject.isVisible = self.settings.svData.pointVisible
			elif solObject.objType == ObjectType.FIXED_POINT:
				solObject.isVisible = self.settings.svData.fPointVisible
			elif solObject.objType == ObjectType.DISTANCE_HELPER:
				solObject.isVisible = self.settings.svData.lineVisible
			elif solObject.objType == ObjectType.DISTANCE_CONSTRAINT:
				solObject.isVisible = self.settings.svData.distanceVisible
			elif solObject.objType == ObjectType.ANGLE_CONSTRAINT:
				solObject.isVisible = self.settings.svData.angleVisible

	def updateViewports(self):
		""" Update the general viewports """
		self.viewportManager.updateViewports()
	
	def isActive(self):
		if self.viewportManager.getActiveViewportType() == self:
			return True
		else:
			return False
		
	def getMainWindow(self):
		""" Return the main window object """
		return self.mainWindow
	
	def createSolution(self):
		""" Create objects for visualisation in the solution view, this action will typically take place, when the system of GCS is solved """
		del self.solutionObjects[:]
		if self.prototypeManager.result != None:
			if len(self.prototypeManager.result.solutions) > 0:
				solution = self.prototypeManager.result.solutions[0]
				for variable in self.prototypeManager.result.variables:
					self.solutionObjects += [Point(variable, Vec(solution[variable]), 5.0)]
				
				self.createDistanceConstraints()
				self.createAngleConstraints()
				self.createDistances()
		self.solutionWidget.update()
	
	def createDistanceConstraints(self):
		""" Create the distance constraints as visualisation between the nodes """	
		distances = filter(lambda c: isinstance(c, geosolver.DistanceConstraint), self.prototypeManager.geoProblem.cg.constraints())		
		for distance in distances:
			beginPoint = self.getSolutionPointByKey(distance._variables[0])
			endPoint = self.getSolutionPointByKey(distance._variables[1])
			distanceConstr = DistanceConstraint("", beginPoint, endPoint)
			distanceConstr.height = distance._value
			distanceConstr.update()
			self.solutionObjects += [distanceConstr]	
	
	def createAngleConstraints(self):
		angles = filter(lambda c: isinstance(c, geosolver.AngleConstraint), self.prototypeManager.geoProblem.cg.constraints())		
		for angle in angles:
			beginPoint = self.getSolutionPointByKey(angle._variables[0])
			middlePoint = self.getSolutionPointByKey(angle._variables[1])
			endPoint = self.getSolutionPointByKey(angle._variables[2])
			angleConstr = AngleConstraint("", beginPoint, middlePoint, endPoint)
			angleConstr.realAngle = angle._value
			angleConstr.update()
			self.solutionObjects += [angleConstr]			
	
	def createDistances(self):
		distances = filter(lambda x:x.objType==ObjectType.DISTANCE_HELPER, self.prototypeManager.prtObjects)
		for distance in distances:
			solPointBegin = filter(lambda x:x.key == distance.pointBegin.key and x.objType==ObjectType.POINT, self.solutionObjects)
			solPointEnd = filter(lambda x:x.key == distance.pointEnd.key and x.objType==ObjectType.POINT, self.solutionObjects)
			solDistance = Distance("", solPointBegin[0], solPointEnd[0])
			solDistance.update()
			self.solutionObjects += [solDistance]
	
	def synchronise(self):
		if self.prototypeManager.result != None:
			prtPoints = filter(lambda x:x.objType == ObjectType.POINT, self.prototypeManager.prtObjects)
			solPoints = filter(lambda x:x.objType == ObjectType.POINT, self.solutionObjects)
			for prtPoint in prtPoints:
				for solPoint in solPoints:
					if prtPoint.key == solPoint.key:
						prtPoint.setPosition(solPoint.position)
			self.prototypeManager.updateObjects()
			self.updateViewports()
					
	def getSolutionPointByKey(self, variable):
		""" Get the first point from the solution by a variable 
		
		Parameters:
			variable - variable which identifies the point which needs to be obtained
		
		Return:
			point - point from the solution object list
		"""	
		point = filter(lambda p: p.key == variable, self.solutionObjects)
		if point != None:
			return point[0]
				
	def drawObjects(self):
		""" Draw the objects in the Solution View """
		for solObj in self.solutionObjects:
			if solObj.isVisible:
				solObj.draw()