Créer une interface pour visualiser les ontologies avec Processing

Un petit tutoriel ?

Ca fait un bout de temps que je cherche, mais là je pense être sur une bonne piste. Le but étant de pouvoir créer facilement l'interface d'une application, en décrivant ses étapes dans une ontologie.
Après quelques tests là et là, l'utilisation de Processing semble être une piste encourageante  ;-).

Et même permettre à des non programmeurs de créer des applications, simplement en les décrivant !

Voici donc la recette d'un "Processing de HelloRdf à la sauce Jena", récupérant les information dans une ontologie (RDF/OWL), le but étant ensuite de récupérer les informations décrites dans la méthode diamond.owl ou de toute autre méthode écrite en rdf/owl pour créér l'application adéquate ;-).
On devrait de la même manière pouvoir visualiser des requêtes Sparql qui retournent des flux formatés RDF.

Pour ceux qui sont trop pressés, le fichier source est disponible ici ( Clic sur Fichier, puis télécharger pour récupérer l'archive complète , A ouvrir avec Processing)
-   helloRdf.zip 
- une autre version avec visualisation de toutes les classes Smag0touteclasseOK

" Processing de HelloRdf à la sauce Jena"

Ingrédients : 

- 1 petit fichier owl/rdf ,
- quelques lignes dans un sketch Processing ,
- quelques librairies Jena pour lier le tout.

Instructions : 

1 : Commençons par préparer nos outils de travail. 

Téléchargez et décompressez, si ce n'est déjà fait, les trois outils suivants. Vous trouverez sur chacun des sites de la documentation détaillée pour l'installation et l'utilisation  :

1. Protege (version utilisée 4.3.0)
2. Processing (version utilisée 2.1.1)
3. Jena (version utilisée 2.11.1)

Un tutoriel de prise en main de chacun de ces logiciels est disponible tout en bas de cette page pour ceux qui ne les maîtriseraient pas  ;-).

Protege et Processing sont des applications et vous pouvez les utiliser directement, par contre, pour Jena, on va seulement utiliser les librairies, comme le décrit Ian Dickinson dans son tutoriel dédié à l'intégration de Jena dans Eclipse :
Commencez par lancer Processing et créez un nouveau sketch vide (un sketch étant un programme dans Processing)  et enregistrez le, par exemlpe sous le nom "helloRdf".

Ceci devrait vous créer un nouveau répertoire "helloRdf" dans Mesdocuments/Processing qui est le répertoire par défaut des sketches de Processing , et à l'intérieur de celui-ci, un fichier helloRdf.pde. Pour visualiser ce répertoire, vous pouvez utiliser le menu Sketch/Show Sketch Folder de l'application Processing.

Comme décrit pour l'intégration de Jena dans Eclipse (Blog de Ian Dickinson) nous allons intégrer les bibliothèques de Jena.

Commencez par créer un répertoire "code" dans le répertoire helloRdf, juste à côté (ou au dessous ;-) du fichier helloRdf.pde. Profitez en également pour créer un répertoire "data" qui nous servira par la suite pour y stocker les fichiers de données :

Rendez-vous ensuite dans le répertoire ou vous avez décompréssé Jena et copiez toutes les librairies (.jar) se trouvant dans le répertoire lib et collez -les dans le répertoire "code" que vous avez créé précedemment dans le répertoire du sketch helloRdf.

Maintenant que nous sommes prêts, mettons-nous au travail.

2 : Création de l'architecture du sketch Processing :

Processing étant basé sur Java , on peut y intégrer toute sorte de package de la même manière, avec import.

import com.hp.hpl.jena.rdf.model.Model;

import com.hp.hpl.jena.rdf.model.Resource;

Insérez ensuite les deux fonctions primordiales de Processing qui permettent de mettre en place (setup) et de dessiner (draw) :

void setup(){

}

void draw(){

}

A l'interieur de la fonction setup(), saisissez les lignes suivantes pour déterminer la taille de l'application et sa couleur de fond : 
  size(300, 300);
  background(255,255,128);

Cliquez ensuite sur l'icone du triangle (ou CTRL+R) pour executer votre code :

Vous devriez voir apparaitre une fenetre identique à celle-ci :

Vous pouvez tester avec d'autres valeurs pour voir leur effet :
size (largeur de la fenêtre, hauteur de la fentre);
background(rouge, vert, bleu, alpha);

Bien ! maintenant que nous savons utiliser Processing, passons aux choses sérieuses : Le paramétrage de cette application grâce à un fichier la décrivant, j'ai nommé l'ontologie "hello.owl"


3. Création de l'ontologie de configuration hello.owl

Commençons par une ontologie très simple, composée d'un seul "Individual", on ne peut pas faire plus simple comme ontologie .
Lancez Protégé et cliquez sur l'onglet "Individuals" :

Cliquez ensuite sur le losange violet avec un plus (attention ! celui qui se trouve dans la fenêtre Individuals, car il y en a plusieurs) :

Créez un nouvel "Individual", c'est à dire une nouvelle Entité (ou Instanciation) et nommez la ProcessingConfiguration en respectant les majuscules :

Le nouvel Individual doit apparaitre dans la fenêtre correspondante :

Profitez-en pour sauvegarder votre fichier "hello.owl" au format (RDF/XML) dans le répertoire "data" du sketch HelloRdf que nous avons précédemment créé avec Processing, par la commande File / SaveAs :

 Enregistrement au format (RDF/XML) dans le répertoire data du sketch HelloRdf

Pour info, il arrive assez régulièrement que Protégé bloque, ou plante carrément quand on tente de cliquer sur un élément tout récemment créé. Si ça vous arrive aussi, pensez à sauvegarder régulièrement ;-).

Ondevrait ensuite pouvoir modifier l'entité ProcessingConfiguration, lors du test et de la confection des copies d'écrans, ça semble bloquer... ok je supprimme cette entité (losange avec une croix dessus) et je la recréé depuis l'onglet Entité en cliquant sur le plus situé à côté de "membres"

Création de l'Entité ProcessingConfiguration :

Cliquez maintenant sur cette Entité, puis sur DataPropertyAssertion, pour lui ajouter des propriétés sizeX, sizeY, background, (grâce aux trois boutons verts) vous devez enregistrer les valeurs une par une et valider à chaque fois :

Voici l'Individual ProcessingConfiguration avec ses propriétés ( attention dataProperty et non Object Property) :

Sauvegardez de nouveau votre fichier "hello.owl" , il est prêt à être utilisé par notre sketch HelloRdf !

4. Les fondations de notre applications étant posés, attaquons nous au bati ! Ah! Tiens ! c'est plus une recette ???

Nous aurons besoin deux deux nouvelles classes dans le sketch HelloRdf : l'une pour instancier notre application et une autre servant d'utilitaire pour la lecture du fichier..


En cliquant dans Processing sur le petit triangle vers le bas vous pourrez créer un "NewTab"... et bien créez en deux : l'un nommé "Application", et l'autre  "OwlFile" et remplissez les comme suit  ( n'oubliez pas de modifier également le premier fichier ( HelloRdf avec le setup qui instancie l'application et récupère les valeurs de cette application !)

code complet de la classe Application : 

class Application {
  String defaultInputFileName="hello.owl";
  int sizeX = 10;
  int sizeY = 20;
  color background = color(0, 0, 0);
  Model model = ModelFactory.createDefaultModel();
  String NS;
  String configURI;


  Application() {
    OwlFile owlFile = new OwlFile(defaultInputFileName);
    creation(owlFile.model);
  } 

  void creation(Model _model) {
    model = _model;
    NS = model.getNsPrefixURI("");
    println("Namespace : "+NS);
    //model.write(System.out);
    // recupere la configuration pour Processing, mais possibilite de creer d'autres fichiers de config selon les supports (html5, Java, ruby, python...) !
    readConfiguration(model, "Processing"); 

    // Affiche la configuration
    println("\n**********************************************************************************\n**********************************************************************************\n");
    println("Cette application utilise le fichier de configuration : \t" +defaultInputFileName);
    println("Les informations de configurations sont des propriétés de l'individual \t "+configURI);
    println("Config décrite dans ce fichier : background :"+hex(background)+" + size : ("+sizeX+","+sizeY+")");
    println("de la même manière, on doit pouvoir creer des pages différentes, des formulaires, des animations, des boutons, des agents (? ;-P)...");
  }


  void readConfiguration(Model _model, String _metaApplication) {
    model = _model;
    String metaApplication = _metaApplication;
    // determine la configuration en fonction de la MetaApplication (une meta application permettant de creer une autre application)
    configURI = NS+metaApplication+"Configuration";
    String sizeXURI = NS+"sizeX";
    String sizeYURI = NS+"sizeY";
    String backgroundURI = NS+"background";
    Resource config  = model.createResource(configURI);
    Property sizeXprop = model.createProperty(sizeXURI);
    Property sizeYprop = model.createProperty(sizeYURI);
    Property backgroundProp = model.createProperty(backgroundURI);
    sizeX =  int(config.getProperty(sizeXprop).getObject().toString());
    sizeY =  int(config.getProperty(sizeYprop).getObject().toString());
    background  =  unhex(config.getProperty(backgroundProp).getObject().toString());
    println("test :"+sizeX+ " "+ sizeY+" "+hex(background));
  }
}

Code complet de la classe OwlFile : 

class OwlFile {
  String inputFileName;
  BufferedReader reader;
  Model model = ModelFactory.createDefaultModel();

  OwlFile(String path) {
    ouverture (path);
  } 

  void ouverture(String _path) {
    inputFileName = _path;
   // println ("cette application utilise le fichier " +inputFileName+);
    reader = createReader(inputFileName);
    // lire le fichier RDF/XML
    model.read(reader, null);
    // l'écrire sur la sortie standard
    // model.write(System.out);
  }
}

Code complet du premier fichier helloRdf.pde :

import com.hp.hpl.jena.rdf.model.Model;
import com.hp.hpl.jena.rdf.model.Resource;

Application application;

void setup(){
  application = new Application();
  size(application.sizeX, application.sizeY);
  background(application.background);
}

void draw() {
  
}


Sauvegardez et cliquez sur le triangle pour lancer l'application helloRdf avec les propriétés que vous avez saisies dans Protégé au format RDF.

Reste plus qu'à récupérer les classes et les Individuals de l'ontologie diamond.owl, et les lier par leur propriétés , pour ce faire, voir  : http://www.gicentre.net/utils

Pour ceux qui sont trop pressés, le fichier source est disponible ici ( Clic sur Fichier, puis télécharger pour récupérer l'archive complète , A ouvrir avec Processing)
-   helloRdf.zip 
- une autre version avec visualisation de toutes les classes Smag0touteclasseOK

Pour Zoomer, tourner, et deplacer : https://www.youtube.com/watch?v=LBrGDqxusVA

Et pour ceux qui découvrent Processing : http://fr.flossmanuals.net/_booki/processing/processing.pdf
Et pour ceux qui découvrent Protégé et les ontologies : http://python.espe-bretagne.fr/master-hst-ue9-2/wp-content/uploads/2013/03/Tutoriel-Pizza-gloria-1.pdf
Et pour ceux qui découvrent Jena :  http://igm.univ-mlv.fr/~ocure/LIGM_LIKE/Teaching/imac3/5_SW.pdf

A plus.... au plaisir de lire vos remarques et commentaires, ou contributions ;-)

Bon c'est pas le tout de rigoler.... mais faut que j'aille bosser, moi...