User Tools

Site Tools


benjamin_letourneau:solution_homework2

Les Données : Projet : FP7 – European money funding research

Choix des données

Initialement, nous voulions utiliser des données sur un domaine avec lequel nous avions une affinité. Après plusieurs essais, nous avons finalement abandonné au profit du jeu de données fourni : FP7 – European money funding research. Nous ne trouvions pas de données fonctionnelles, utilisables et exploitables.

Ce jeu de données représente les participations des pays pour différents projets. Il y a de nombreux attributs et chaque entrée est unique grâce à une clé : (Projet, Organisation). Un attribut permet de lier un projet à une stratégie (domaine de recherche).

À partir de ces données, nous allons représenter les liaisons entre les différents pays selon les projets, les stratégies ainsi que les subventions fournies par l’Union Européenne.

Nettoyage des données pour l’analyse

Nous avons tout d’abord nettoyé les données dans le fichier Excel. C’est à dire, renommer certaines colonnes afin d’obtenir un code plus propre. Exemple : « EU financial contribution rate » est devenu « EU_FINANCIAL_CONTRIBUTION_RATE ».

Nous avons par la suite supprimé des colonnes trop incomplètes de notre jeu de données comme : « REGION_CODE ».

Nous avons, pour terminer le nettoyage du fichier Excel, vérifié tous les types de données. Les « EU_FINANCIAL_CONTRIBUTION » étaient sous forme « text », il fallait donc les passer à « number ».

Après avoir exporté la feuille de données sous forme CSV, nous avons importés les données dans Tulip. Une fois cet import de données terminé, nous avons vérifié que les données sont cohérentes. Malheureusement, une erreur s’était passée, neuf entrées n’ont pas été importées comme prévu, nous avons donc choisi de les supprimer du jeu de données.

Les questions

Pour répondre aux différentes questions nous avons choisi de travailler à partir d’une représentation qu’on améliorerait/modifierait selon le besoin. En effet, nous n’avons pas eu autant de temps que nous l’aurions souhaité à consacrer à ce projet. Ainsi, pour réaliser au mieux notre travail nous avons optimisé nos algorithmes : un algorithme de base va traiter les données en plusieurs sous graphes imbriqués qui seront adaptés et clusturisés.

Nous avons choisi de répondre à une question pertinente en la découpant en plusieurs questions afin de guider notre travail et notre réflexion. De cette façon, nous avons pu améliorer nos connaissances et compréhensions de l’outil Tulip.

Question 1 : Quels pays reçoivent le plus grand financement pour leurs recherches par l’Union Européenne ?

Pour commencer, nous avons implémenté 2 sous graphes et un cluster.

Pour répondre à cette question, nous avons trié nos données et créé ces types de segmentation :

  • Méta-Node : Nous avons regroupé toutes les unités (Projet, Pays) en un noeud représentant le pays (plus de doublon de pays),
  • Deux sous graphes :
    • « Country » : Qui va contenir nos méta-nodes correspondant à tous les pays du jeu de données,
    • « World » : Qui va contenir le sous-graphe « Country »
  • Cluster : On va séparer tous les Méta-Node (Pays) selon la catégorie fournie dans le jeu de données : COUNTRY_TYPE. Celle-ci correspond à la localisation grossière du pays :
    • Member States (UE),
    • Associated States (Europe),
    • Developing Country (? monde),
    • Others (Autres).

Nous avons fait ce choix pour regrouper les noeuds du graphe selon leur « localisation ». Pour renforcer cette idée d’appartenance à cette catégorie, nous avons coloré chaque noeud selon COUNTRY_TYPE.

Finalement, pour terminer notre algorithme, nous avons représenté le financement de l’UE par pays à travers la taille du noeud. Les pays les plus financés sont les plus gros et les moins financés les plus petits.

Le problème à ce stade était que la différence entre les pays les plus aidés et ceux moins aidés était bien trop importante (~60.000 à ~1.000.000.000). La visualisation était inexploitable. Ainsi nous avons implémenté un affichage par palier avec des tailles fixes. La différence est toujours très importante, mais la vue nous permet de réaliser les différences.

Cette implémentation a un défaut : les pays recevant ~1.000.000.000 (essentiellement en Europe) sont rares et ceux recevant ~60.000 (? monde et autres) sont plus nombreux.

Nous avons jugé ceci acceptable, car on voulait montrer que les pays Européens recevaient le plus de subventions.

Question 2 : Quels sont les pays qui ont le plus de projets, où encore, quels sont les plus grands acteurs dans la recherche subventionnée par l’Union Européenne ?

Pour répondre à cette question, nous avons choisi de réutiliser le même algorithme que celui de la question 1 pour faire une comparaison avec l’argent subventionné.

La seule différence est que la taille du noeud n’est plus sur la totalité de l’argent reçu, mais sur le nombre de projets total traité dans le pays.

Pour conclure, l’argent est bien corrélé avec le nombre de projets. Pour citer un exemple : L’Allemagne reçoit la plus haute subvention pour une somme de près de 1 milliard avec le plus grand nombre de projets à près de 4000.

Question 3 : Quelles sont les collaborations entre les pays européens et les différents pays du monde ?

Encore une fois, pour répondre à la question, nous avons conservé l’algorithme précédent en le modifiant légèrement. Nous avons ajouté un sous-graphe entre « World » et « Country » : « Country_type ». Nous avons fait cette modification pour lier chaque country_type par une arête unique affichant le nombre de projets en commun.

N’ayant pas trouvé le moyen d’afficher une information sur une arête, nous avons stocké le nombre de projets représenté par cette arête dans la propriété « PROJECT » de celle-ci. Nous pouvons accéder à cette valeur à l’aide de bouton « ? » de l’interface Tulip.

Pourquoi une unique arête ? Nous avons essayé de lier chaque pays avec les pays collaborateurs pour un projet. Cela a généré une visualisation apocalyptique. Il y avait tellement d'arêtes qu’on ne voyait plus les sommets.

Ce choix d’implémentation nous a permis d’avoir une information sur la collaboration entre les « COUNTRY_TYPE ». Mais nous voulions montrer les liens entre les pays.

Pour ce faire, nous avons créé un sous-graphe pour chaque pays qui va contenir les noeuds (pays) qui ont un projet en commun avec lui. Ainsi en cliquant sur les noeuds des pays on affiche uniquement les noeuds qui nous intéressent et l'on enlève les autres pour une visualisation améliorée. De ce fait, on peut facilement observer les liaisons pour chaque pays avec le reste du monde.

Question 4 : Quelles sont les différences budgétaires entre les objectifs stratégiques ?

Nous avons choisi de représenter la répartition budgétaire entre les différents objectifs stratégiques par un histogramme (la hauteur de l’histogramme correspond au budget alloué par l’Union Européenne aux projets correspondant aux objectifs).

Initialement, nous avions voulu, en cliquant sur une colonne de l’histogramme, pouvoir afficher le sous-graphe correspondant à l’ensemble des pays travaillant sur un projet traitant de cet objectif. C’est pour cela que nous avons reconstruit une nouvelle structure de données différente des questions précédentes.

La structure est la suivante :

  • Objectif Stratégique
    • objectif 1
      • pays contenant un projet traitant cet objectif
    • objectif 2
      • pays contenant un projet traitant cet objectif

Projet Tulip et code source python

Voici le lien vers une archive permettant de tester notre travail (projet Tulip).https://www.dropbox.com/s/2zdh1x5ftiv2cxy/Project.zip?dl=0

Voici le code source python de notre projet :

codeSource.py
# Powered by Python 2.7
 
from tulip import *
import math
 
#################################################################
################### Variables Globales ##########################
#################################################################
factor = 1500.0
 
 
####################################################
################### Utils ##########################
####################################################
# Creer un sous graphe
# name = Nom
def createSubGraph(graph, name):
	return graph.addSubGraph(name);
 
#Permet de cacher les noeuds initiaux present dans le graphe
def cleanOutput(graph):
	for n in graph.getNodes():
		graph.getSizeProperty("viewSize")[n] = tlp.Size(0)
 
# Permet de renvoyer le permier noeud dont la valeur Pays coreespond
# node_list => la liste
# name => le nom du pays
def getNodeByName(graph, node_list, name) :
	node = None
	for n in node_list :
		if graph.getProperty("COUNTRY")[n] == name :
			node = n
			break
 
	return node
 
# Permet de definir des paliers de valeurs selon un nombre passe en parametre
def computeFloor(max_money):
	nb_floors = 10
	floors=[float(i) for i in range(nb_floors)]
 
	for i, w in enumerate(floors):
		floors[i] = float(max_money*(float(i+1)/float(nb_floors)))
 
	return floors
 
# Permet de savoir si deux noeuds font parti du meme cluster
# Les clusters correspondent au type de pays (country_type)
def inSameCluster(node1, node2):
	return graph.getProperty("COUNTRY_TYPE")[node1] == graph.getProperty("COUNTRY_TYPE")[node2]
 
# Permet de renvoyer le metha-noeud qui correspond au cluster du noeud en parametre
# node => noeud de comparaison
# metha_node_list => liste des metha-noeuds
def getMethaNodeTypeInList(metha_node_list, node):
	metha_node = None
	for n in metha_node_list: 
		if inSameCluster(n, node):
			metha_node = n
			break
	return metha_node
 
# Permet d'ajouter une arrete entre deux noeuds et de gerer le nombre d'arretes entre ces deux noeuds
def addEdgeInGraph(graph, node1, node2):
	if not graph.hasEdge(node1,node2, False) :
		edge = graph.addEdge(node1, node2)
		graph.getIntegerProperty("PROJECT")[edge] += 1
	else:
		edges = graph.getEdges(node1,node2)
		for edge in edges:
			graph.getIntegerProperty("PROJECT")[edge] += 1
 
######################################################
################Graphics part#########################
######################################################
 
# Permet de placer les metha-noeuds de la question 3
# ceux ci sont afficher hors du cluster (cercle) pour une question de visualisation
def clustering_type(graph, node_list):
	for node in node_list: 
		if graph.getProperty("COUNTRY_TYPE")[node] == "Member States":
			graph.getLayoutProperty("viewLayout")[node] = tlp.Coord(-factor*0.3, factor*0.3)
		elif graph.getProperty("COUNTRY_TYPE")[node] == "Associated Countries":
			graph.getLayoutProperty("viewLayout")[node] = tlp.Coord(factor*0.3, factor*0.3)
		elif graph.getProperty("COUNTRY_TYPE")[node] == "Developing Countries":
			graph.getLayoutProperty("viewLayout")[node] = tlp.Coord(-factor*0.3, -factor*0.3)
		elif graph.getProperty("COUNTRY_TYPE")[node] == "All Others Countries":
			graph.getLayoutProperty("viewLayout")[node] = tlp.Coord(factor*0.3, -factor*0.3)
 
# Permet d'afficher les noeuds de chaque clusters dans un cercle
def clustering(graph, node_list) :
 
	cluster = dict()
 
	for node in node_list :
		country_type = graph.getProperty("COUNTRY_TYPE")[node]
 
		if not country_type in cluster:
			cluster[country_type] = []
 
		cluster[country_type].append(node)
 
	#Member States
	if "Member States" in cluster :
		tetha = float(360)/len(cluster["Member States"])
		cpt = 0.0
		rayon = 1300.0
		for node in cluster["Member States"] : 
			cpt+=1.0
			x= -factor+(math.cos ( tetha*cpt ) * rayon)
			y= factor + (math.sin (tetha*cpt) * rayon)
			graph.getLayoutProperty("viewLayout")[node] = tlp.Coord(x, y)
 
	#Associated Countries
	if "Associated Countries" in cluster :
		tetha = 360/len(cluster["Associated Countries"])
		cpt = 0.0
		rayon = 850.0
		for node in cluster["Associated Countries"] : 
			cpt+=1.0
			x = factor+(math.cos(tetha*cpt)*rayon)
			y = factor+(math.sin(tetha*cpt)*rayon)
			graph.getLayoutProperty("viewLayout")[node] = tlp.Coord(x, y)
 
	#Developpement Countrties
	if "Developing Countries" in cluster :
		tetha = 360/len(cluster["Developing Countries"])
		cpt = 0.0
		rayon = 1200.0
		for node in cluster["Developing Countries"] : 
			cpt+=1.0
			x = -factor+(math.cos(tetha*cpt)*rayon)
			y = -factor+(math.sin(tetha*cpt)*rayon)
			graph.getLayoutProperty("viewLayout")[node] = tlp.Coord(x,y)
 
	#All Other Countries
	if "All Others Countries" in cluster :
		tetha = 360/len(cluster["All Others Countries"])
		cpt = 0.0
		rayon = 850.0
		for node in cluster["All Others Countries"] : 
			cpt+=1.0
			x = factor+(math.cos(tetha*cpt)*rayon)
			y = -factor+(math.sin(tetha*cpt)*rayon)
			graph.getLayoutProperty("viewLayout")[node] = tlp.Coord(x,y)
 
# Permet de gerer la taille d'un noeud en fonction d'une valeur et de paliers
def sizeNode(graph, node, value, floors, factor_size = 300000):
	graph.getIntegerProperty("viewShape")[node] = tlp.NodeShape.Circle	
 
	for floor in floors :
		if value <= floor :
			graph.getSizeProperty("viewSize")[node] = tlp.Size(floor/factor_size,floor/factor_size,1)
			break
 
# Permet d'afficher un label dans le noeud
def labelNode(graph, node, country, cpt_project, money_for_country, so = None):
	label = country + "\n" + "Nb Projet : " + str(cpt_project) + "\n"
	if not money_for_country is None:
		label += str(money_for_country) + " euro"
	if not so is None:
		label += "\nNb strategies : " + str(so)		
 
	graph.getColorProperty("viewLabelBorderColor")[node] = tlp.Color(tlp.Color.Black)
	graph.getStringProperty("viewLabel")[node] = label
 
# Permet de colorer un noeud selon son type de pays (cluster)
def colorNode(graph, node, country_type) :
	if country_type == "Member States" :
		graph.getColorProperty("viewColor")[node] = tlp.Color(tlp.Color.Red)
	elif country_type == "Associated Countries" :
		graph.getColorProperty("viewColor")[node] = tlp.Color(tlp.Color.Orange)
	elif country_type == "Developing Countries" :
		graph.getColorProperty("viewColor")[node] = tlp.Color(tlp.Color.Green)
	elif country_type == "All Others Countries" :
		graph.getColorProperty("viewColor")[node] = tlp.Color(tlp.Color.Blue)
 
#################################################################
###################		Questions		##########################
#################################################################
	# QUESTION : Quels pays recoivent le plus grand financement pour leurs recherches par l'Union Europeenne
def question1(graph) :
	# Sous graphe qui va contenir nos metha-noeud
	world = createSubGraph(graph, "World");
 
	# Dictionnaire de sous graphe qui va contenir les noeuds correpondant a un pays 
	# la cle est le nom du pays
	countries = dict()
	# Dictionnaire d'entier qui va contenir l'argent totale fournit pour l'ensembles des projets d'un pays 
	# la cle est le nom du pays
	money_for_a_country = dict()
	# Dictionnaire de liste qui va contenir les strategies de chaque pays 
	# la cle est le nom du pays
	country_so = dict()
	# Dictionnaire qui va contenir le type d'un pays : Europe, Union Europeenne, Autres, Pays associes
	# la cle est le nom du pays
	country_type = dict()
	# Dictionnaire de liste qui va contenir le nom des pays participant a un projet
	# la cle est l'identifiant du projet
	projects = dict()
 
	# Pour chaque noeud :
	for n in graph.getNodes():
		# On recupere le nom du pays et l'id du projet correspondant
		country = graph.getProperty("COUNTRY")[n]
		project = graph.getProperty("PROJECT")[n]
 
		 #initialisation des variables ...
		if not project in projects :
			projects[project] = []	
 
		if not country in projects[project] :
			projects[project].append(country)
 
		if not country in countries :
			money_for_a_country[country] = 0
 
			countries[country] = createSubGraph(world, country)
			#on initialise une variable qui va representer le nombre de projet pour le pays selectione
			# ici cpt_project correspond au nombre de projet de "country"
			countries[country].setAttribute("cpt_project", 0)
			country_type[country] = graph.getProperty("COUNTRY_TYPE")[n]
 
		if not country in country_so :
			country_so[country] = []
 
		if graph.getProperty("SO_AGGREGATED")[n] not in country_so[country] :
			country_so[country].append(graph.getProperty("SO_AGGREGATED")[n])
 
		# on ajoute le noeud dans son sous graphe (Pays)
		countries[country].addNode(n)
 
		# On incremente le compteur de projet pour ce pays
		countries[country].setAttribute("cpt_project",  countries[country].getAttribute("cpt_project")+1)
 
		# On ajoute le financement du projet actuel pour ce pays dans son financement global
		money_for_a_country[country] += graph.getProperty("EU_FINANCIAL_CONTRIBUTION")[n]
 
	# 7 lignes => On calcul des paliers pour la taille des noeuds selon le financement maximum
	max_money_for_country = 0
 
	for mfc in money_for_a_country :
		if max_money_for_country < money_for_a_country[mfc]:
			max_money_for_country = money_for_a_country[mfc]
 
	floors = computeFloor(max_money_for_country)
 
	# Liste contenant les meta-noeuds que l'on va creer
	# Un meta-noeud correspond a un pays
	our_node_list = []	
 
	# Pour tous les pays
	for country in countries :
		# On creer le meta-noeud et on l'ajoute dans la liste
		node = countries[country].createMetaNode(countries[country], True, True)
		our_node_list.append(node)
 
		# On insert les donnees dans le meta-noeud
		graph.getProperty("COUNTRY")[node] = country
		graph.getProperty("COUNTRY_TYPE")[node] = country_type[country]
 
		# on appel les methodes permettant de gerer l'affichage de nos donnees calcule
		colorNode(graph, node,country_type[country])
		sizeNode(graph, node, money_for_a_country[country], floors, 3500000)
		labelNode(graph, node, country, countries[country].getAttribute("cpt_project"), money_for_a_country[country], len(country_so[country]))
 
		world.addNode(node)
 
	clustering(world, our_node_list)
 
#########################################################################################################
 
#########################################################################################################
 
 
	# QUESTION : Quels sont les pays qui ont le plus de projets, ou encore, 
	# quels sont les plus grands acteurs dans la recherche subventionnes par l'Union Europeenne
def question2(graph) :
	# Sous graphe qui va contenir nos metha-noeud
	world = createSubGraph(graph, "World");
 
	# Dictionnaire de sous graphe qui va contenir les noeuds correpondant a un pays 
	# la cle est le nom du pays
	countries = dict()
	# Dictionnaire d'entier qui va contenir l'argent totale fournit pour l'ensembles des projets d'un pays 
	# la cle est le nom du pays
	money_for_a_country = dict()
	# Dictionnaire qui va contenir le type d'un pays : Europe, Union Europeenne, Autres, Pays associes
	# la cle est le nom du pays
	country_type = dict()
	# Dictionnaire de liste qui va contenir le nom des pays participant a un projet
	# la cle est l'identifiant du projet
	projects = dict()
 
	# Pour chaque noeud :
	for n in graph.getNodes():
		# On recupere le nom du pays et l'id du projet correspondant
		country = graph.getProperty("COUNTRY")[n]
		project = graph.getProperty("PROJECT")[n]
 
		 #initialisation des variables ...
		if not project in projects :
			projects[project] = []	
 
		if not country in projects[project] :
			projects[project].append(country)
 
		if not country in countries :
			money_for_a_country[country] = 0
 
			countries[country] = createSubGraph(world, country)
			#on initialise une variable qui va representer le nombre de projet pour le pays selectione
			# ici cpt_project correspond au nombre de projet de "country"
			countries[country].setAttribute("cpt_project", 0)
			country_type[country] = graph.getProperty("COUNTRY_TYPE")[n]
 
		# on ajoute le noeud dans son sous graphe (Pays)
		countries[country].addNode(n)
 
		# On incremente le compteur de projet pour ce pays
		countries[country].setAttribute("cpt_project", countries[country].getAttribute("cpt_project")+1)
 
		# On ajoute le financement du projet actuel pour ce pays dans son financement global
		money_for_a_country[country] += graph.getProperty("EU_FINANCIAL_CONTRIBUTION")[n]
 
	# 7 lignes => On calcul des paliers pour la taille des noeuds selon le nombre de projets
	max_project_for_country = 0
 
	for country in countries :
		if max_project_for_country < countries[country].getAttribute("cpt_project"):
			max_project_for_country = countries[country].getAttribute("cpt_project")
 
	floors = computeFloor(max_project_for_country)
 
	# Liste contenant les meta-noeuds que l'on va creer
	# Un meta-noeud correspond a un pays
	our_node_list = []	
 
	# Pour tous les pays
	for i in countries :
		# On creer le meta-noeud et on l'ajoute dans la liste
		node = countries[i].createMetaNode(countries[i], True, True)
		our_node_list.append(node)
 
		# On insert les donnees dans le meta-noeud
		graph.getProperty("COUNTRY")[node] = i
		graph.getProperty("COUNTRY_TYPE")[node] = country_type[i]
 
		# on appel les methodes permettant de gerer l'affichage de nos donnees calcule
		colorNode(graph, node,country_type[i])
		sizeNode(graph, node, countries[i].getAttribute("cpt_project"), floors, 10)
		labelNode(graph, node, i, countries[i].getAttribute("cpt_project"), money_for_a_country[i])
 
		world.addNode(node)
 
	# on affiche les donnees triee
	clustering(world, our_node_list)
 
#########################################################################################################
 
#############################################################################################################
 
# QUESTION : Quelles sont les collaborations entre les pays europeens et les differents pays du monde
def question3(graph) :
	# Sous graphe qui va contenir nos metha-noeud
	world = createSubGraph(graph, "World");	
 
	# Dictionnaire de sous graphe qui va contenir les noeuds correpondant a un pays 
	# la cle est le nom du pays
	countries = dict()
	# Dictionnaire d'entier qui va contenir l'argent totale fournit pour l'ensembles des projets d'un pays 
	# la cle est le nom du pays
	money_for_a_country = dict()
	# Dictionnaire qui va contenir le type d'un pays : Europe, Union Europeenne, Autres, Pays associes
	# la cle est le nom du pays
	country_type = dict()
	# Dictionnaire qui va contenir sous graphe correspondant au type d'un pays
	# la cle est le type du pays
	country_type_subgraph = dict()
	# Dictionnaire de liste qui va contenir le nom des pays participant a un projet
	# la cle est l'identifiant du projet
	projects = dict()
 
	# Pour chaque noeud :
	for n in graph.getNodes():
		# On recupere le nom du pays et l'id du projet correspondant
		country = graph.getProperty("COUNTRY")[n]
		project = graph.getProperty("PROJECT")[n]
 
		 #initialisation des variables ...
		if not project in projects :
			projects[project] = []	
 
		if not country in projects[project] :
			projects[project].append(country)
 
		if not world.getSubGraph(graph.getProperty("COUNTRY_TYPE")[n]):
			country_type_subgraph[graph.getProperty("COUNTRY_TYPE")[n]] = createSubGraph(world, graph.getProperty("COUNTRY_TYPE")[n])
 
		if not country in countries :
			money_for_a_country[country] = 0
 
			countries[country] = createSubGraph(world.getSubGraph(graph.getProperty("COUNTRY_TYPE")[n]), country)
			#on initialise une variable qui va representer le nombre de projet pour le pays selectione
			# ici cpt_project correspond au nombre de projet de "country"
			countries[country].setAttribute("cpt_project", 0)
			country_type[country] = graph.getProperty("COUNTRY_TYPE")[n]
 
		# on ajoute le noeud dans son sous graphe (Pays)
		countries[country].addNode(n)
 
		# On incremente le compteur de projet pour ce pays
		countries[country].setAttribute("cpt_project", countries[country].getAttribute("cpt_project")+1)
 
		# On ajoute le financement du projet actuel pour ce pays dans son financement global
		money_for_a_country[country] += graph.getProperty("EU_FINANCIAL_CONTRIBUTION")[n]
 
	node_list = []
 
	# on cree les metha-noeuds qui correspondent a chaque cluster
	for ct in country_type_subgraph :
		metha_node_ct = country_type_subgraph[ct].createMetaNode(country_type_subgraph[ct], True, True)
		node_list.append(metha_node_ct)
		graph.getProperty("COUNTRY_TYPE")[metha_node_ct] = ct
		graph.getColorProperty("viewLabelBorderColor")[metha_node_ct] = tlp.Color(tlp.Color.Black)
		graph.getStringProperty("viewLabel")[metha_node_ct] = ct
		graph.getIntegerProperty("viewShape")[metha_node_ct] = tlp.NodeShape.Square
		graph.getDoubleProperty("viewBorderWidth")[metha_node_ct] = 0.0
		graph.getColorProperty("viewColor")[metha_node_ct] = tlp.Color(tlp.Color.White)
		graph.getSizeProperty("viewSize")[metha_node_ct] = tlp.Size(0,0,1)
 
	# on les affiches
	clustering_type(world, node_list)
 
	# 7 lignes => On calcul des paliers pour la taille des noeuds selon le nombre de projets
	max_project_for_country = 0
 
	for country in countries :
		if max_project_for_country < countries[country].getAttribute("cpt_project"):
			max_project_for_country = countries[country].getAttribute("cpt_project")
 
	floors = computeFloor(max_project_for_country)	
 
	# Liste contenant les meta-noeuds correspondant aux pays que l'on va creer
	# Un meta-noeud correspond a un pays
	our_node_list = []	
 
	# Pour tous les pays
	for i in countries :
		for metha_node_type in node_list:
			if metha_node_type not in countries[i].getNodes() :
				countries[i].addNode(metha_node_type)		
 
		# On creer le meta-noeud et on l'ajoute dans la liste
		node = countries[i].createMetaNode(countries[i], True, True)
		our_node_list.append(node)
 
		# On insert les donnees dans le meta-noeud
		graph.getProperty("COUNTRY")[node] = i
		graph.getProperty("COUNTRY_TYPE")[node] = country_type[i]
 
		# on appel les methodes permettant de gerer l'affichage de nos donnees calcule
		colorNode(graph, node,country_type[i])
		sizeNode(graph, node, countries[i].getAttribute("cpt_project"), floors, 10)
		labelNode(graph, node, i, countries[i].getAttribute("cpt_project"),None)
 
		world.addNode(node)
 
	clustering(world, our_node_list)
 
	country_sub_graph = dict()
 
	# on gere les arretes	
	for project in projects :
		for i, country in enumerate(projects[project]) :
			cpt = 0
			node1 = getNodeByName(world, our_node_list, country)
			for country2 in projects[project][i+1:len(projects[project])]:
				node2 = getNodeByName(world, our_node_list, country2)
				if not country in country_sub_graph:
					country_sub_graph[country] = createSubGraph(countries[country], country)
					country_sub_graph[country].addNode(node1)
					for metha_node_type in node_list:
						country_sub_graph[country].addNode(metha_node_type)
 
				country_sub_graph[country].addNode(node2)
 
				if inSameCluster(node1, node2):
					metha_node_1 = getMethaNodeTypeInList(node_list, node1)
					addEdgeInGraph (country_sub_graph[country],node1,node2)
				else :
					metha_node_1 = getMethaNodeTypeInList(node_list, node1)
					metha_node_2 = getMethaNodeTypeInList(node_list, node2)
					addEdgeInGraph (graph,metha_node_1,metha_node_2)
					addEdgeInGraph (country_sub_graph[country],metha_node_1,metha_node_2)
					addEdgeInGraph (country_sub_graph[country],node1,metha_node_1)
					addEdgeInGraph (country_sub_graph[country],metha_node_2,node2)
 
	for node in node_list:
		for edge in graph.getInOutEdges(node):
			graph.getColorProperty("viewLabelBorderColor")[edge] = tlp.Color(tlp.Color.Black)
			graph.getStringProperty("viewLabel")[edge] = graph.getIntegerProperty("PROJECT")[edge]
####################################################################################################
 
#########################################################################################################
 
	# QUESTION : Quelles sont les differences budgetaires entre les objectifs strategiques
def question4(graph):
	strategic_objective = createSubGraph(graph, "Strategic Objective")
 
	# Dictionnaire d'entier qui va contenir l'argent totale fournit pour l'ensembles des projets d'un pays 
	# la cle est le nom du pays
	money_for_a_so = dict()
 
	# Dictionnaire qui va contenir le type d'un pays : Europe, Union Europeenne, Autres, Pays associes
	# la cle est le nom du pays
	country_type = dict()
 
	# Dictionnaire qui va contenir les themes des differents projets
	# la cle est le theme
	soa = dict()
 
	# Pour chaque noeud :
	for n in graph.getNodes():
		# On recupere le nom du pays et l'id du projet correspondant
		country = graph.getProperty("COUNTRY")[n]
		so = graph.getProperty("SO_AGGREGATED")[n]
 
		# a so
		if not strategic_objective.getSubGraph(so):
			soa[so] = createSubGraph(strategic_objective, so)
			money_for_a_so[so] = 0
 
		soa[so].addNode(n)		
		money_for_a_so[so] += graph.getProperty("EU_FINANCIAL_CONTRIBUTION")[n]
 
		#country
		if soa[so].getSubGraph(country) is None :
			createSubGraph(soa[so], country)
			country_type[country] = graph.getProperty("COUNTRY_TYPE")[n]
		soa[so].getSubGraph(country).addNode(n)
 
 
	counrty_node_list = []	
	for sg in graph.getSubGraph("Strategic Objective").getSubGraphs():
		for country in sg.getSubGraphs() :
			node = country.createMetaNode(country, True, True)
			graph.getSizeProperty("viewSize")[node] = tlp.Size(0,0,0)
			graph.getProperty("COUNTRY")[node] = country.getName()
			graph.getProperty("COUNTRY_TYPE")[node] = country_type[country.getName()]
			counrty_node_list.append(node)
			graph.addNode(node)
 
	so_node_list = []
	step = 0
	size = 200
	margin = 10
 
	# on affiche l'histogramme
	for key, so in sorted(money_for_a_so.items(), lambda a,b: cmp(a[1],b[1]),reverse=False):
		node = soa[key].createMetaNode(soa[key], True, True)
		heigth = so/1000000
		graph.getSizeProperty("viewSize")[node] = tlp.Size(size, heigth, 0)
		graph.getLayoutProperty("viewLayout")[node] = tlp.Coord(step, heigth/2)
		graph.getColorProperty("viewLabelBorderColor")[node] = tlp.Color(tlp.Color.Black)
		graph.getIntegerProperty("viewShape")[node] = tlp.NodeShape.Square
		graph.getStringProperty("viewLabel")[node] = key
		var = (255*heigth)/950
		print	var
		graph.getColorProperty("viewColor")[node] = tlp.Color(255,255-var,102)
 
 
		so_node_list.append(node)
		step += size + margin
 
###########################################################
###################		Main		##########################
###########################################################
 
def main(graph): 
 
	cleanOutput(graph)
	########################################
	########################################
	### Quels pays recoivent le plus grand financement pour leur recherche 
	### par l'union europeenne
	########################################
	########################################
#	question1(graph)
	########################################
 
 
 
	########################################
	########################################
	### Quels sont les pays qui ont le plus de projets, ou encore, quels sont 
	### les plus grands acteurs dans la recherche subventionne par l'Union Europeenne
	########################################
	########################################
#	question2(graph)
	########################################
 
 
 
	########################################
	########################################
	# Quelles sont les collaborations entre les pays europeens et les differents pays du monde
	########################################
	########################################
#	question3(graph)
	########################################
 
 
 
	########################################
	########################################
	# Quelles sont les differences budgetaires entre les objectifs strategiques ?
	########################################
	########################################
#	question4(graph)
	########################################
 
	updateVisualization(True)	
/net/html/perso/melancon/Visual_Analytics_Course/data/pages/benjamin_letourneau/solution_homework2.txt · Last modified: 2015/01/13 16:48 by letourneau