def __init__(self, graph, fileName):
self.graph = graph
self.fileName = fileName
self.type = self.graph.getStringProperty('type')
self.ids = self.graph.getStringProperty('rcmnId')
self.weights = self.graph.getDoubleProperty('edgeWeight')
self.substrate = 'group'
self.catalyst = 'member'
self.graphHandler = GraphHandler()
def __init__(self, bipartiteGraph, substrateGraph, substrateTypeName = 'substrate', catalystTypeName = 'catalyst'):
self.bipartiteGraph = bipartiteGraph
self.superGraph = self.bipartiteGraph.getSuperGraph()
self.substrateGraph = substrateGraph
self.catalystGraph = None
self.substrateTypeName = substrateTypeName
self.catalystTypeName = catalystTypeName
self.type = self.bipartiteGraph.getStringProperty('type')
self.ids = self.bipartiteGraph.getStringProperty('rcmnId')
self.weights = self.bipartiteGraph.getDoubleProperty('edgeWeight')
self.graphHandler = GraphHandler()
def __init__(self, analysisGraph, substrateTypeName="substrate", catalystTypeName="catalyst"):
self.superGraph = analysisGraph
self.bipartiteGraph = analysisGraph.addCloneSubGraph()
self.bipartiteGraph.setName("bipartiteGraph")
self.substrateGraph = None
self.substrateTypeName = substrateTypeName
self.catalystTypeName = catalystTypeName
self.type = self.bipartiteGraph.getStringProperty("type")
self.ids = self.bipartiteGraph.getStringProperty("rcmnId")
self.weights = self.bipartiteGraph.getDoubleProperty("edgeWeight")
self.graphHandler = GraphHandler()
def __init__(self, QWidget, consoleOutput, parent=None):
QtGui.QWidget.__init__(self, parent)
#Unlike better languages, you have to manually call the super constructor
super(CaptureArea, self).__init__()
#this is just used to print to console output
self.consoleOut = consoleOutput
#This is auto generated code. Notice the names
self.gridLayout_2 = QtGui.QGridLayout(QWidget)
self.gridLayout_2.setObjectName(_fromUtf8("gridLayout_2"))
self.captureArea = QtGui.QTabWidget(QWidget)
self.captureArea.setObjectName(_fromUtf8("captureArea"))
#Stores the 4 camera threads
self.cvObjectLists = []
#The graph handler object
self.graphHandler = GraphHandler(self, consoleOutput)
#Each tabs has 3 parts, they are lists so the user can make unlimited tabs
self.tabs = []
self.gridLayouts = []
self.widgets = []
self.captureArea.insertTab(3, self.graphHandler, "plot")
#after creating all the tabs for capture area, add it to the layout. This is the whole otter layout.
self.gridLayout_2.addWidget(self.captureArea, 0, 0, 1, 1)
self.connect(self.gridLayout_2, QtCore.SIGNAL("resized()"),
self.onResize)
self.newTab()
self.newTab()
self.newTab()
def undo(self):
if len(self.state_stack) > 1:
self.state_stack.pop()
try:
self.CurrentStateSnapshot = self.state_stack[-1]
except IndexError:
print "no more undo-operations stored!"
self.figure.clf()
self.graph = self.CurrentStateSnapshot.graph
self.selected_nodes = self.CurrentStateSnapshot.selected_nodes
self.digraph_on = self.CurrentStateSnapshot.digraph_on
self.normalized = self.CurrentStateSnapshot.normalized
self.GH = GraphHandler.GraphHandler(self.figure, self.name_dict,\
self.CurrentStateSnapshot)
else:
print "no more undo-operations stored!"
def main():
parser = argparse.ArgumentParser(description="run a genetic algorithm to solve the travelling salesman problem")
req = parser.add_argument_group("required arguments")
req.add_argument("-i", "--input_file", help="the input .tsp file", required=True)
parser.add_argument("-o", "--output_file", help="optional output file for the bests and averages", default=None)
parser.add_argument("-mx", "--max_gen", help="the maximum number of generations to run for (default=1000)",
type=int, default=1000)
parser.add_argument("-ps", "--pop_size", help="the population size (default=50)", default=50, type=int)
parser.add_argument("-cr", "--cross_rate", help="the crossover rate (default=1.0)", type=float, default=1.0)
parser.add_argument("-mr", "--mut_rate", help="the mutation rate (default=0.1)", type=float, default=0.1)
parser.add_argument("-cm", "--cross_mode", help="the mode of crossover, 0 for uox, 1 for pmx (default=0)",
choices=[0, 1], type=int, default=0)
args = parser.parse_args()
try:
fh = GraphHandler(args.input_file)
except IOError as err:
print(err)
sys.exit(0)
tsp = TSP(fh, args.output_file, args.max_gen, args.pop_size, args.cross_rate, args.mut_rate, args.cross_mode)
tsp.genetic_algorithm()
class CatalystProjector:
'''
this class takes as input a bipartite graph
and the associated (projected) substrate graph
and projects it on entities of one type
the class requires that:
- nodes of the original graph have an "id" attribute (string)
- nodes of the original graph have a two-value "type" attribute (string)
- edges have weights (positive real numbers) stored in a 'edgeWeight' property (double)
used to sort out entities, one of these value is used to compute the projected graph
edges of the resulting graph moreover will hold an attribute ";" concatenating id's of all
entities f leading to edge e1 - e2 (under a property names name catalystTypeName)
'''
def __init__(self, bipartiteGraph, substrateGraph, substrateTypeName = 'substrate', catalystTypeName = 'catalyst'):
self.bipartiteGraph = bipartiteGraph
self.superGraph = self.bipartiteGraph.getSuperGraph()
self.substrateGraph = substrateGraph
self.catalystGraph = None
self.substrateTypeName = substrateTypeName
self.catalystTypeName = catalystTypeName
self.type = self.bipartiteGraph.getStringProperty('type')
self.ids = self.bipartiteGraph.getStringProperty('rcmnId')
self.weights = self.bipartiteGraph.getDoubleProperty('edgeWeight')
self.graphHandler = GraphHandler()
def catalystProjection(self):
'''
create catalyst subgraph, insert all necessary nodes
'''
selected = self.bipartiteGraph.getBooleanProperty('selected')
selected.setAllNodeValue(False)
for n in self.bipartiteGraph.getNodes():
if self.type[n] == self.catalystTypeName:
selected[n] = True
self.catalystGraph = self.superGraph.addSubGraph(selected)
self.catalystGraph.setName(self.catalystTypeName + 'Projection')
'''
assign weights to catalyst nodes
'''
catalystIds = self.catalystGraph.getStringProperty('rcmnId')
catalystWeights = self.catalystGraph.getDoubleProperty('edgeWeight')
substrateIds = self.substrateGraph.getStringProperty('rcmnId')
substrateWeights = self.substrateGraph.getDoubleProperty('edgeWeight')
for e in self.substrateGraph.getEdges():
catalystList = substrateIds[e].split(';')
for id in catalystList:
n = self.graphHandler.findNodeById(id, self.catalystGraph, catalystIds, False)
catalystIds[n] = id
catalystWeights[n] += substrateWeights[e]
'''
scan catalyst (as attributes of edges in substrate subgraph)
and accordingly instantiate edges in catalyst subgraph
assign weights to catalyst edges
'''
for e in self.substrateGraph.getEdges():
catalystList = substrateIds[e].split(';')
for i in range(len(catalystList)):
for j in range(i + 1, len(catalystList)):
n1 = self.graphHandler.findNodeById(catalystList[i], self.catalystGraph, catalystIds, False)
n2 = self.graphHandler.findNodeById(catalystList[j], self.catalystGraph, catalystIds, False)
f = self.graphHandler.findEdge(n1, n2, self.catalystGraph, True)
catalystWeights[f] += substrateWeights[e]
class CaptureArea(QtGui.QWidget):
#This is how you pass a QWidget (MainWindow from main.py) to a class
def __init__(self, QWidget, consoleOutput, parent=None):
QtGui.QWidget.__init__(self, parent)
#Unlike better languages, you have to manually call the super constructor
super(CaptureArea, self).__init__()
#this is just used to print to console output
self.consoleOut = consoleOutput
#This is auto generated code. Notice the names
self.gridLayout_2 = QtGui.QGridLayout(QWidget)
self.gridLayout_2.setObjectName(_fromUtf8("gridLayout_2"))
self.captureArea = QtGui.QTabWidget(QWidget)
self.captureArea.setObjectName(_fromUtf8("captureArea"))
#Stores the 4 camera threads
self.cvObjectLists = []
#The graph handler object
self.graphHandler = GraphHandler(self, consoleOutput)
#Each tabs has 3 parts, they are lists so the user can make unlimited tabs
self.tabs = []
self.gridLayouts = []
self.widgets = []
self.captureArea.insertTab(3, self.graphHandler, "plot")
#after creating all the tabs for capture area, add it to the layout. This is the whole otter layout.
self.gridLayout_2.addWidget(self.captureArea, 0, 0, 1, 1)
self.connect(self.gridLayout_2, QtCore.SIGNAL("resized()"),
self.onResize)
self.newTab()
self.newTab()
self.newTab()
def resizeEvent(self, evt=None):
print("HEYT \n")
self.emit(QtCore.SIGNAL("resize()"))
print("HEYT \n")
def newTab(self):
self.tabs.append(QtGui.QWidget())
tabObjectName = "tab" + str(len(self.tabs) - 1)
self.tabs[(len(self.tabs) - 1)].setObjectName(_fromUtf8(tabObjectName))
self.gridLayouts.append(
QtGui.QGridLayout(self.tabs[len(self.tabs) - 1]))
gridLayoutObjectName = "gridLayout" + str(len(self.gridLayouts) - 1)
self.gridLayouts[len(self.gridLayouts) - 1].setObjectName(
_fromUtf8(gridLayoutObjectName))
self.widgets.append(QtGui.QWidget(self.tabs[len(self.tabs) - 1]))
widgetObjectName = "widget" + str(len(self.widgets) - 1)
self.widgets[len(self.widgets) - 1].setObjectName(
_fromUtf8(widgetObjectName))
self.gridLayouts[len(self.gridLayouts) - 1].addWidget(
self.widgets[len(self.widgets) - 1], 0, 0, 1, 1)
self.captureArea.addTab(self.tabs[len(self.tabs) - 1], _fromUtf8(""))
#this sets the last tab is the current tab
#self.captureArea.setCurrentWidget(self.tabs[(len(self.tabs) - 1)])
def removeTab(self, index):
widget = self.captureArea.widget(index)
if widget is not None:
widget.deleteLater()
self.captureArea.removeTab(index)
def start_clicked(self):
lastWidget = self.getWidget()
self.cvHandler3 = CVHandler(self.widgets[lastWidget],
"tcp://192.168.2.6:9092",
self.graphHandler)
self.cvHandler3.start_clicked()
def connectToCameras(self):
print("TEST")
self.captureArea.setCurrentWidget(self.tabs[0])
lastWidget = self.getWidget()
try:
cvHandler = CVHandler(self.widgets[lastWidget],
"tcp://192.168.1.100:9092", 100,
self.graphHandler)
self.cvObjectLists.append(cvHandler)
self.newTab()
# self.cvHandler2 = CVHandler(self.widgets[1], "tcp://192.168.2.201:9092", self.graphHandler)
# self.cvHandler2.start_clicked()
# self.consoleOut.outputText("Playing video from webcam")
except:
self.consoleOut.outputText(
"Error has occurred while connecting to 192.168.1.100")
try:
#cvHandler = CVHandler(self.widgets[lastWidget], "tcp://192.168.1.101:9092", 101, self.graphHandler)
#self.cvObjectLists.append(cvHandler)
self.newTab()
# self.cvHandler2 = CVHandler(self.widgets[1], "tcp://192.168.2.201:9092", self.graphHandler)
# self.cvHandler2.start_clicked()
# self.consoleOut.outputText("Playing video from webcam")
except:
self.consoleOut.outputText(
"Error has occurred while connecting to 192.168.1.101")
lastWidget = self.getWidget()
try:
#cvHandler = CVHandler(self.widgets[lastWidget], "tcp://192.168.1.102:9092", 102, self.graphHandler)
#self.cvObjectLists.append(cvHandler)
self.newTab()
# self.cvHandler2 = CVHandler(self.widgets[1], "tcp://192.168.2.201:9092", self.graphHandler)
# self.cvHandler2.start_clicked()
# self.consoleOut.outputText("Playing video from webcam")
except:
self.consoleOut.outputText(
"Error has occurred while connecting to 192.168.1.102")
lastWidget = self.getWidget()
try:
cvHandler = CVHandler(self.widgets[lastWidget],
"tcp://192.168.1.103:9092", 103,
self.graphHandler)
#self.cvObjectLists.append(cvHandler)
#self.newTab()
# self.cvHandler2 = CVHandler(self.widgets[1], "tcp://192.168.2.201:9092", self.graphHandler)
# self.cvHandler2.start_clicked()
# self.consoleOut.outputText("Playing video from webcam")
except:
self.consoleOut.outputText(
"Error has occurred while connecting to 192.168.1.103")
lastWidget = self.getWidget()
for cv in self.cvObjectLists:
cv.start_clicked()
def deleteThisLater(self):
self.graphHandler.testtest()
def recordMotion(self):
#self.cvHandler2.recordMotion()
if (len(self.cvObjectLists) > 0):
for cv in self.cvObjectLists:
cv.recordMotion()
else:
self.consoleOut.outputText("No cameras connected")
def stopRecording(self):
if (len(self.cvObjectLists) > 0):
for cv in self.cvObjectLists:
cv.stopRecording()
else:
self.consoleOut.outputText("No cameras connected")
def takeCalibrationPicture(self):
if (len(self.cvObjectLists) > 0):
for cv in self.cvObjectLists:
self.consoleOut.outputText("Taking Pictures")
cv.takeCalibrationPic()
else:
self.consoleOut.outputText("No cameras connected")
def stop_playback(self):
try:
self.cvHandler2.stop_playback()
self.consoleOut.outputText("Video has stopped")
except:
self.consoleOut.outputText("No camera connected at this time")
def playBackMotion(self):
self.graphHandler.playbackMotion()
def connectToIP(self, ipAddress, test):
self.newTab()
test.connectToStream(self)
def getWidget(self):
#CaptureArea.newTab()
#lastTab = len(self.tabs) - 1
lastWidget = len(self.widgets) - 1
return int(lastWidget)
def getGraph(self):
return self.graphHandler
def openVideoFile(self, fileName):
pass
def openMaskingDebugWindow(self):
self.debugWin = MaskingDebug()
def onResize(self):
self.window_width = self.widgets[0].frameSize().width()
self.window_height = self.widgets[0].frameSize().height()
self.openGLHandler.updateWindowSize(self.window_width,
self.window_height)
def getWindowHeight(self):
return self.window_height
def getWindowWidth(self):
return self.window_width
def updateWindowSize(self):
#print("wht the f**k")
self.window_width = self.captureArea.frameSize().width()
self.window_height = self.captureArea.frameSize().height()
#this is going to check if the camera is recording, because there are 6 cam, we need an int
def isRunning(self, cam=0):
#self.cvHandler2[0].isRunning()
return self.cvHandler2.isRunning()
def updatePoints(self):
self.cvHandler2.setPoints()
print("test")
'''
class SubstrateProjector:
"""
this class takes as input a bipartite graph
(typically obtained using a loader class, see KublaiLoader for example)
and projects it on entities of one type
projected paths e1 - f - e2 induce edges e1 - e2
weights on edges e1 - f, f - e2 combine and define
weights on edges e1 - e2
the class requires that:
- nodes of the original graph have an "id" attribute (string)
- nodes of the original graph have a two-value "type" attribute (string)
- edges have weights (positive real numbers) stored in a 'edgeWeight' property (double)
used to sort out entities, one of these value is used to compute the projected graph
edges of the resulting graph moreover will hold an attribute ";" concatenating id's of all
entities f leading to edge e1 - e2 (under a property names name catalystTypeName)
caution: the graph should have been obtained form whatever convenient loader class
and then needs to be cloned -- the code should operate on the clone graph (new
entities will be added to he original graph)
"""
def __init__(self, analysisGraph, substrateTypeName="substrate", catalystTypeName="catalyst"):
self.superGraph = analysisGraph
self.bipartiteGraph = analysisGraph.addCloneSubGraph()
self.bipartiteGraph.setName("bipartiteGraph")
self.substrateGraph = None
self.substrateTypeName = substrateTypeName
self.catalystTypeName = catalystTypeName
self.type = self.bipartiteGraph.getStringProperty("type")
self.ids = self.bipartiteGraph.getStringProperty("rcmnId")
self.weights = self.bipartiteGraph.getDoubleProperty("edgeWeight")
self.graphHandler = GraphHandler()
def substrateProjection(self):
selected = self.bipartiteGraph.getBooleanProperty("selected")
selected.setAllNodeValue(False)
for n in self.bipartiteGraph.getNodes():
if self.type[n] == self.substrateTypeName:
selected[n] = True
self.substrateGraph = self.superGraph.addSubGraph(selected)
self.substrateGraph.setName(self.substrateTypeName + "Projection")
weights = self.substrateGraph.getDoubleProperty("edgeWeight")
catalystIds = self.substrateGraph.getStringProperty("rcmnId")
for s1 in self.substrateGraph.getNodes():
for s2 in self.substrateGraph.getNodes():
if (not s1.id == s2.id) and (self.graphHandler.findEdge(s1, s2, self.substrateGraph, False) == None):
catalystSet = self.graphHandler.commonNeighbors(s1, s2, self.bipartiteGraph)
if len(catalystSet) > 0:
e = self.substrateGraph.addEdge(s1, s2)
catalystIds.setEdgeValue(e, self.__catalystListValue__(catalystSet))
weights[e] = self.__scalarProduct__(s1, s2, catalystSet)
def __scalarProduct__(self, s1, s2, catalystSet):
prod = 0.0
for c in catalystSet:
e1 = self.graphHandler.findEdge(c, s1, self.bipartiteGraph, False)
e2 = self.graphHandler.findEdge(c, s2, self.bipartiteGraph, False)
prod += self.weights[e1] * self.weights[e2]
return prod
def __catalystListValue__(self, catalystSet):
cIds = []
for c in catalystSet:
cIds.append(self.ids.getNodeValue(c))
return ";".join(cIds)
class KublaiLoader:
def __init__(self, graph, fileName):
self.graph = graph
self.fileName = fileName
self.type = self.graph.getStringProperty('type')
self.ids = self.graph.getStringProperty('rcmnId')
self.weights = self.graph.getDoubleProperty('edgeWeight')
self.substrate = 'group'
self.catalyst = 'member'
self.graphHandler = GraphHandler()
def processFile(self):
'''
builds a bipartite graph with edges connecting substrates (documents/grups)
to catalysts (terms/members) -- substrates interact through catalysts
todo/wishlist: would need to process time data as well (post dates)
'''
self.graph.clear()
f = open(self.fileName, "r")
obj = json.loads(f.read())
topics = [t for t in obj]
for t in topics:
self.__processTopic__(t)
mh = MetricHandler(self.graph)
mh.rescale(self.weights, [1.0, 10.0], 'edges')
def __processTopic__(self, topic):
idContributor = topic["contributorName"].encode('UTF-8')
if "groupId" not in topic.keys():
return None
idGroup = topic["groupId"].encode('UTF-8')
content = topic["description"].encode('UTF-8')
nContrib = self.graphHandler.findNodeById(idContributor, self.graph, self.ids, True)
nGroup = self.graphHandler.findNodeById(idGroup, self.graph, self.ids, True)
e = self.graphHandler.findEdge(nContrib, nGroup, self.graph)
self.weights[e] += len(content)
if "comments" in topic.keys():
for c in topic["comments"]:
if self.__processComment__(c, idGroup, nGroup) == None:
print c
def __processComment__(self, comment, idGroup, nodeGroup):
idContributor = comment["contributorName"].encode('UTF-8')
if comment["description"] == None:
print idGroup
print idContributor
return None
content = comment["description"].encode('UTF-8')
nContrib = self.graphHandler.findNodeById(idContributor, self.graph, self.ids, True)
e = self.graphHandler.findEdge(nContrib, nodeGroup, self.graph, True)
self.weights[e] += len(content)
return True
n2 = GS.Node(0, 9, 1) #B
n3 = GS.Node(10, 0, 1) #C
n4 = GS.Node(10, 10, 1) #D
# These should never be here and are only for debug purpose
e1 = GS.Edge(n1, n2) #AB
e2 = GS.Edge(n1, n3) #AC
e3 = GS.Edge(n2, n4) #BD
e4 = GS.Edge(n3, n4) #CD
e5 = GS.Edge(n1, n4)
start_nodes = [n1, n2, n3, n4]
start_edges = [] #[e1, e2, e3, e4, e5]
GH = gh.GraphHandler()
for node in start_nodes:
GH.addNode(node)
for edge in start_edges:
GH.addEdgeObj(edge)
valueX = ''
valueY = ''
while valueX != 'exit' or valueY != 'exit':
valueX = float(input("Value X of new node: "))
valueY = float(input("Value Y of new node: "))
if isinstance(valueX,
(int, long, float)) and isinstance(valueY,
import GraphHandler as g
import MessageHandler as m
exit = False
baudrate = 15500
timeout = None
port_name = "COM4"
Gui = g.GraphHandler()
MsgHandler = m.MessageHandler(port_name, baudrate_=baudrate, timeout_=timeout)
MsgHandler.StartCommunication()
while (not Gui.exit):
for i in range(3 * g.NUMBER_OF_KINETIS):
msg = MsgHandler.ReadFrame()
MsgHandler.ManageMessage(msg, len(msg))
list_of_positions = MsgHandler.GetPositions()
Gui.UpdateBoards(list_of_positions)
MsgHandler.EndCommunication()
type=int,
help='set multicast port')
parser.add_argument('-ip',
'--set_stream_ip',
action='store',
default='224.2.10.100',
help='set multicast ip address group')
# for testing purposes
parser.add_argument(
'-om',
'--set_output_mode',
action='store',
default='print',
choices=['print', 'store', 'graph'],
help=
'set multicast output mode, print to terminal, store to file, or graph (requires ui) (default="print")'
)
args = parser.parse_args()
mcast = multicast(args.set_stream_ip, args.set_stream_port,
args.set_stream_type, args.set_output_mode)
if args.set_output_mode in ['store', 'print']:
mcast.output()
else:
tsg = gh.GraphHandler(mcast.generator())
# tsg = gh.TimeSeriesGraph(stream().read())
def __init__(self, source_path, dest_path):
self.state_stack = [] #stores snapshots of current states
self.max_stored_states = 10 #defines the maximum number of possible undo actions
work_name = os.path.basename(
source_path) #name of the directory we are working in
self.source_path = source_path #path to the working directory
if dest_path == None:
dest_path = source_path #if specified: path to the directory files will be saved to
self.name_dict = {
'work_name':
work_name, #store names in dictionary to make things cleaner
'source_path': source_path,
'dest_path': dest_path
}
self.graph = None #try to load the graph object
for f in os.listdir(self.name_dict['source_path']
): #look for a file that ends with '_red1.gpickle'
if f.endswith(
'_red1.gpickle'
): #this corresponds to a graph which has some redundant nodes left
self.graph = load(join(self.name_dict['source_path'], f))
if self.graph == None: #if no suitable file is found, print an error message
print 'No corresponding .gpickle-file found!'\
+' (looking for _red1.gpickle)\nClosing the GUI.'
printHelp() #print the help message and exit the GUI
sys.exit()
self.selected_nodes = {
} #stores the keys of the currently selected nodes
self.mode_list = [
] #list of currently switched on modes which will be displayed at the top of the figure
#state flags
self.select_on = False #node selection mode on?
self.digraph_on = False #is the graph already a digraph?
self.normalized = False #has the graph already been streamlined? (redundant nodes removed)
self.shift_on = False #is the shift key pressed? (ugly but working modifier handling...)
#figure initialization
self.dpi = 100 #resolution, increase for super crowded graphs
self.figsize = (
12, 12
) #size of the figure, tinker with this if the displayed figure does not fit your monitor
self.figure = plt.figure(dpi=self.dpi, figsize=self.figsize)
#initialize state stack and mode
self.CurrentStateSnapshot = StateSnapshot(
self.graph, #take an initial snapshot and store it
self.selected_nodes,
self.digraph_on,
self.normalized)
self.update_state_stack()
self.GH = GraphHandler.GraphHandler(
self.figure,
self.name_dict, #initialize the graph handler
self.CurrentStateSnapshot)
self.update_mode("Image: " + self.name_dict['work_name'],
'add') #update the display at the top of the figure
self.edit_loop() #start the main interaction loop
