analyzers/__init__.py

@@ -51,7 +51,7 @@ __MAPPING__ = {
 		StoreRender
 	],
 	SimulationOrderAnalyzer: [
-		#JSONRender,
+		JSONRender,
 		# SimulationOrderRender,
 		SimulationGroupRender
 	]

analyzers/analyzer/__init__.py

@@ -50,7 +50,7 @@ class ResultStore:
 		:return:
 		"""
 		result = []
-		for key in sorted(self.store):
+		for key in self.store:
 			result += self.store[key]
 		return result
 

analyzers/analyzer/biogames.py

@@ -195,7 +195,6 @@ class ActivityMapper(Analyzer):
 			board_data = get_board_data(self.settings.source, self.instance_config_id, entry["sequence_id"],
 										entry["board_id"])
 			entry["extra_data"] = board_data
-			entry["extra_data"]["activity_type"] = self.last_board_type
 			entry['coordinate'] = self.new_coordinate()
 			self.timeline.append(entry)
 		return False
@@ -237,8 +236,6 @@ class ActivityMapper(Analyzer):
 		self.track['properties'].update(props)
 		self.tracks.append(self.track)
 		self.track = self.new_track(props['end_timestamp'])
-		if self.last_coordinate:
-			self.track['coordinates'].append(self.last_coordinate)
 
 	def new_track(self, timestamp):
 		return {"type": "LineString", "coordinates": [], "properties": {'start_timestamp': timestamp}}

analyzers/render/biogames.py

@@ -185,13 +185,7 @@ class SimulationOrderRender(Render):
 
 class SimulationGroupRender(Render):
 	def render(self, results: List[Result], name=None):
-		#data = [r.get() for r in self.filter(results)]
+		data = [r.get() for r in self.filter(results)]
-		data = []
-		for r in self.filter(results):
-			raw = r.get()
-			if len(raw) < 6:
-				raw = [0] + raw
-			data.append(raw)
 		print(name, len(data))
 		graph_plot(list(data), ylabel="simulation retries", title="sequential simulation retries", rotation=None, name=name)
 		#graph_fit(list(data), name=name)

biogames2.json

@@ -14,7 +14,6 @@
   "analyzers": {
     "analyzers": [
       "SimulationCategorizer",
-      "SimulationOrderAnalyzer",
       "ActivityMapper"
     ]
   },

log_analyzer.py

@@ -63,8 +63,7 @@ if __name__ == '__main__':
 	# "fec57041458e6cef98652df625", ]
 	log_ids = []
 	# with open("/home/clemens/git/ma/test/filtered") as src:
-	if False:
+	with open("/home/clemens/git/ma/test/filtered") as src:
-		with open("/home/clemens/git/ma/test/filtered_5_actions") as src:
 		for line in src:
 			line = line.strip()
 			log_ids.append(line)
@@ -123,8 +122,6 @@ if __name__ == '__main__':
 	if True:
 		#json.dump(store.serializable(), open("new.json", "w"), indent=1)
 		from collections import defaultdict
-		import matplotlib.pyplot as plt
-		from util.meta_temp import CONFIG_NAMES
 
 		keys = [
 			"simu",
@@ -133,17 +130,14 @@ if __name__ == '__main__':
 			"audio",
 			"video",
 			"other",
-			"map",
+			"map"
-			# "error"
 		]
+		import matplotlib.pyplot as plt
+		#results = []
 
-
-		def get_data(store, relative_values=True, sort=True, show_errors=False):
 		places = defaultdict(list)
 
 		for log in store.get_all():
-				if not log.analysis() == analyzers.ActivityMapper:
-					continue
 			result = defaultdict(lambda: 0)
 			for i in log.get()['track']:
 				duration = i['properties']['end_timestamp'] - i['properties']['start_timestamp']
@@ -157,270 +151,60 @@ if __name__ == '__main__':
 				percentage[i]= result[i]/total
 				minutes[i] = result[i]/60_000
 			print(json.dumps(percentage,indent=4))
-				if not 'error' in result or show_errors:
-					if relative_values:
-						places[log.get()['instance']].append(percentage)
-					else:
-						places[log.get()['instance']].append(minutes)
-			if sort:
-				for place in places:
-					places[place] = sorted(places[place], key=lambda item: item['map'])
-			return places
-
-
-		from shapely.geometry import LineString
-		from shapely.ops import transform
-		from functools import partial
-		import pyproj
-
-
-		def calc_distance(coordinates):
-			track = LineString(coordinates)
-			project = partial(
-				pyproj.transform,
-				pyproj.Proj(init='EPSG:4326'),
-				pyproj.Proj(init='EPSG:32633'))
-			return transform(project, track).length
-
-		whitelist = ['16fc3117-61db-4f50-b84f-81de6310206f', '5e64ce07-1c16-4d50-ac4e-b3117847ea43',
-					 '90278021-4c57-464e-90b1-d603799d07eb', 'ff8f1e8f-6cf5-4a7b-835b-5e2226c1e771']
-
-
-		def get_data_distance(store, relative_values=True, sort=True, show_errors=False):
-			places = defaultdict(list)
-
-			for log in store.get_all():
-				if not log.analysis() == analyzers.ActivityMapper:
-					continue
-				result = defaultdict(lambda: 0)
-				for i in log.get()['track']:
-					coords = i['coordinates']
-					if len(coords) > 1:
-						distance = calc_distance(coords)
-						result[i['properties']['activity_type']] += distance
-				total = sum(result.values())
-				percentage = defaultdict(lambda: 0)
-				for i in result:
-					if not total == 0:
-						percentage[i] = result[i] / total
-				if not 'error' in result or show_errors:
-					if relative_values:
-						places[log.get()['instance']].append(percentage)
-					else:
-						places[log.get()['instance']].append(result)
-			if sort:
-				for place in places:
-					places[place] = sorted(places[place], key=lambda item: item['map'])
-			return places
-
-
-		def get_all_data(store, sort=False, relative=True):
-			places = defaultdict(list)
-			simu_distribution = defaultdict(lambda: 0)
-			#divisiors = {"time":60_000, "space":1000000}
-			for log in store.get_all():
-				if not log.analysis() == analyzers.ActivityMapper:
-					continue
-				result = defaultdict(lambda: defaultdict(lambda: 0))
-				for i in log.get()['track']:
-					coords = i['coordinates']
-					if len(coords) > 1:
-						distance = calc_distance(coords)
-					else:
-						distance = 0.0
-					result["space"][i['properties']['activity_type']] += distance
-					duration = i['properties']['end_timestamp'] - i['properties']['start_timestamp']
-					result["time"][i['properties']['activity_type']] += duration
-				total_space = sum(result["space"].values())
-				total_time = sum(result["time"].values())
-				percentage = defaultdict(lambda: defaultdict(lambda: 0))
-				total = defaultdict(lambda: defaultdict(lambda: 0))
-				for i in result["space"]:
-					if not total_space == 0:
-						percentage[i]["space"] = result["space"][i] / total_space
-					else:
-						percentage[i]["space"] = 0
-					if not total_time == 0:
-						percentage[i]["time"] = result["time"][i] / total_time
-					else:
-						percentage[i]["time"] = 0
-					for t in ("space","time"):
-						#total[i][t] += (result[t][i] / divisiors[t])
-						total[i][t] += result[t][i]
-				print(percentage)
 			if not 'error' in result:
-					if relative:
+				#places[log.get()['instance']].append(percentage)
-						value = percentage
+				places[log.get()['instance']].append(minutes)
-					else:
-						value = total
-					places[log.get()['instance']].append(value)
-					simus = defaultdict(lambda :0)
-					for item in log.get()['boards']:
-						if item["extra_data"]["activity_type"]=="simu":
-							simus[item["board_id"]] += 1
-					simu_distribution[len(simus)]+=1
 
-			if sort:
 		for place in places:
-					places[place] = sorted(places[place], key=lambda item: item['map']['time'])
+			places[place] = sorted(places[place], key=lambda item:item['map'])
-			print(simu_distribution)
-			return places
 
-
-		def stack_data(keys, places, type="time"):
-			divisiors = {"time": 60_000, "space": 1000}
-			divisiors = {"time": 1, "space": 1}
 		dummy = [0]*len(keys)
 		results = []
 		sites = []
-			for i in sorted(places):
+		from util.meta_temp import CONFIG_NAMES
-				if not i in whitelist:
+		for i in places:
-					continue
 			for j in places[i]:
 				ordered = []
 				for k in keys:
-						if k in j:
+					ordered.append(j[k])
-							ordered.append(j[k][type]/divisiors[type])
-						else:
-							ordered.append(0)
-					print(sum(ordered))
-					if sum(ordered) > 0.9:
-						#print(sum(ordered), 1-sum(ordered))
-						#if sum(ordered)<1:
-						#	ordered[-2] = 1-sum(ordered[:-2], ordered[-1])
 				results.append(ordered)
 			results.append(dummy)
 			sites.append(CONFIG_NAMES[i] if i in CONFIG_NAMES else "---")
-			return results, sites
 
 
-		def plot_data(places, keys):
-			results, sites = stack_data(keys, places)
-			dpi=86.1
-			plt.figure(figsize=(1280/dpi, 720/dpi))
 		size = len(results)
-			print("{} elements total".format(size))
 		ind = np.arange(size)
-			width = 1
+		width=0.9
-			# print(results)
+		print(results)
 		data = list(zip(*results))
-			# print(data)
+		print(data)
 		lines = []
-			bottom = [0] * size
+		bottom = [0]*len(results)
-			plt.ticklabel_format(useMathText=False)
 		for i in range(0, len(data)):
 			lines.append(plt.bar(ind,data[i], bottom=bottom, width=width)[0])
 			for k,x in enumerate(data[i]):
 				bottom[k] += x
 		plt.legend(lines, keys)
 		plt.title(", ".join(sites))
-			#plt.show()
-			dpi=86
-			plt.savefig("time_rel_{}.png".format(size), dpi=dpi,bbox_inches="tight")
-
-
-		colors = {
-			"simu": "blue",
-			"question": "orange",
-			"image": "green",
-			"audio": "red",
-			"video": "purple",
-			"other": "brown",
-			"map": "violet",
-			# "error":"grey"
-		}
-		markers = [".", "o", "x", "s", "*", "D", "p", ",", "<", ">", "^", "v", "1", "2", "3", "4"]
-
-
-		def plot_time_space(time_data, space_data, keys):
-			# assuming time_data and space_data are in same order!
-			marker = 0
-			for id in time_data:
-				for k in keys:
-					for i in range(len(time_data[id])):
-						print(time_data[id][i][k], space_data[id][i][k])
-						plt.plot(time_data[id][i][k], space_data[id][i][k], color=colors[k], marker=markers[marker])
-				marker += 1
 		plt.show()
 
-
+	#size = len(results)
-		# plt.cla()
+	#ind = np.arange(size)
-		# plt.clf()
+	#width = 0.9
-		# plt.close()
+	#print(results)
-
+	#data = list(zip(*results))
-		def plot_time_space_rel(combined, keys):
+	#print(data)
-			groups = defaultdict(list)
+	#lines = []
-			keys = list(keys)
+	#bottom = [0] * len(results)
-			keys.remove("other")
+	#for i in range(0, len(data)):
-			ids = []
+	#	lines.append(plt.bar(ind, data[i], bottom=bottom, width=width)[0])
-			for k in keys:
+	#	for k, x in enumerate(data[i]):
-				for id in sorted(combined):
+	#		bottom[k] += x
-					if id not in whitelist:
+	#plt.legend(lines, keys)
-						continue
+	#plt.title("Zwei Spiele in Filderstadt (t1=237min; t2=67min)")
-					if not id in ids:
-						ids.append(id)
-					group = 0.0
-					count = 0
-					for item in combined[id]:
-						if k in item:
-							time = item[k]["time"]/1000
-							distance = item[k]["space"]
-							if time > 0:
-								group += (distance / time)
-								count+=1
-							else:
-								print("div by zero", distance, time)
-					if count > 0:
-						groups[k].append(group/count)
-					else:
-						groups[k].append(0.0)
-			print(ids)
-			ind = np.arange(len(ids))
-			width = .7 / len(groups)
-			print(ind)
-			print(json.dumps(groups, indent=1))
-			bars = []
-			dpi=10
-			plt.figure(figsize=(1280/dpi, 720/dpi))
-			fig, ax = plt.subplots()
-			for k in groups:
-				print(groups[k])
-				if not len(groups[k]):
-					groups[k].append(0)
-				ind = ind + (width)
-				bars.append(ax.bar((ind + width*len(groups)/2), groups[k], width, color=colors[k]))
-			ax.set_xticks(ind + width / 2)
-			ax.set_xticklabels(list([CONFIG_NAMES[i] if i in CONFIG_NAMES else "---" for i in ids]))
-			plt.legend(bars, keys)
-			print(combined.keys(), ids)
-			print([CONFIG_NAMES[i] if i in CONFIG_NAMES else "---" for i in ids])
 	#plt.show()
-			dpi=100
-			plt.savefig("speed.png", dpi=dpi)
 
 
-		# spatial_data = get_data_distance(store,relative_values=False)
-		# temporal_data = get_data(store,relative_values=False)
-		# spatial_data_rel = get_data_distance(store,relative_values=True)
-		# temporal_data_rel = get_data(store,relative_values=True)
-		#temporal_data_rel = json.load(open("temporal_rel.json"))
-		#spatial_data_rel = json.load(open("spatial_rel.json"))
-		# import IPython
-		# IPython.embed()
-
-		#print(json.dumps(get_all_data(store)))
-		#json.dump(get_all_data(store), open("combined.json", "w"))
-		#combined = get_all_data(store, sort=True, relative=True)
-		#json.dump(combined, open("combined_rel.json", "w"))
-		#combined = json.load(open("combined_rel.json"))
-		combined = json.load(open("combined_total.json"))
-		plot_time_space_rel(combined, keys)
-
-		#plot_time_space_rel(temporal_data_rel, spatial_data_rel, keys)
-
-		#plot_data(combined, keys)
-	# plot_data(get_data_distance(store,relative_values=False), keys)
-
 
 # for analyzers in analyzers:
 #	if analyzers.name() in ["LogEntryCount", "ActionSequenceAnalyzer"]:

requirements.txt

@@ -5,4 +5,3 @@ osmnx==0.6
 networkx==2.0
 pydot==1.2.3
 scipy==1.0.0
-ipython==6.2.1