22/12/2013

Test d'intégration de Apache Jena -Sparql dans Processing.org pour visualiser les rdf

Voir le tutoriel plus récent : http://smag0.blogspot.fr/2014/03/creer-une-interface-pour-visualiser-les.html


import com.hp.hpl.jena.query.* ;

int nodeCount;
Node[] nodes = new Node[10];
HashMap nodeTable = new HashMap();

int edgeCount;
Edge[] edges = new Edge[5];

static final color nodeColor   = #F0C070;
static final color selectColor = #FF3030;
static final color fixedColor  = #FF8080;
static final color edgeColor   = #000000;

PFont font;

void setup() {
  size(600, 600);
  // loadData();
  // println(edgeCount);
  font = createFont("SansSerif", 10);


  // File file = new File();
  Rdf rdftest = new Rdf();
}

void addEdge(String fromLabel, String toLabel) {
  // Filter out unnecessary words
  if (ignoreWord(fromLabel) || ignoreWord(toLabel)) return;

  Node from = findNode(fromLabel);
  Node to = findNode(toLabel);
  from.increment();
  to.increment();

  for (int i = 0; i < edgeCount; i++) {
    if (edges[i].from == from && edges[i].to == to) {
      edges[i].increment();
      return;
    }
  }

  Edge e = new Edge(from, to);
  e.increment();
  if (edgeCount == edges.length) {
    edges = (Edge[]) expand(edges);
  }
  edges[edgeCount++] = e;
}


String[] ignore = {
  "a", "of", "the", "i", "it", "you", "and", "to"
};

boolean ignoreWord(String what) {
  for (int i = 0; i < ignore.length; i++) {
    if (what.equals(ignore[i])) {
      return true;
    }
  }
  return false;
}


Node findNode(String label) {
  label = label.toLowerCase();
  Node n = (Node) nodeTable.get(label);
  if (n == null) {
    return addNode(label);
  }
  return n;
}


Node addNode(String label) {
  Node n = new Node(label);
  if (nodeCount == nodes.length) {
    nodes = (Node[]) expand(nodes);
  }
  nodeTable.put(label, n);
  nodes[nodeCount++] = n;
  return n;
}

void draw() {
  if (record) {
    beginRecord(PDF, "output.pdf");
  }

  background(255);
  textFont(font);
  smooth();

  for (int i = 0 ; i < edgeCount ; i++) {
    edges[i].relax();
  }
  for (int i = 0; i < nodeCount; i++) {
    nodes[i].relax();
  }
  for (int i = 0; i < nodeCount; i++) {
    nodes[i].update();
  }
  for (int i = 0 ; i < edgeCount ; i++) {
    edges[i].draw();
  }
  for (int i = 0 ; i < nodeCount ; i++) {
    nodes[i].draw();
  }

  if (record) {
    endRecord();
    record = false;
  }
}
boolean record;

void keyPressed() {
  if (key == 'r') {
    record = true;
  }
}


Node selection;


void mousePressed() {
  // Ignore anything greater than this distance
  float closest = 20;
  for (int i = 0; i < nodeCount; i++) {
    Node n = nodes[i];
    float d = dist(mouseX, mouseY, n.x, n.y);
    if (d < closest) {
      selection = n;
      closest = d;
    }
  }
  if (selection != null) {
    if (mouseButton == LEFT) {
      selection.fixed = true;
    } else if (mouseButton == RIGHT) {
      selection.fixed = false;
    }
  }
}


void mouseDragged() {
  if (selection != null) {
    selection.x = mouseX;
    selection.y = mouseY;
  }
}


void mouseReleased() {
  selection = null;
}

// EDGE
// Code from Visualizing Data, First Edition, Copyright 2008 Ben Fry.
// Based on the GraphLayout example by Sun Microsystems.


class Edge {
  Node from;
  Node to;
  float len;
  int count;



  Edge(Node from, Node to) {
    this.from = from;
    this.to = to;
    this.len = 50;
  }


  void increment() {
    count++;
  }


  void relax() {
    float vx = to.x - from.x;
    float vy = to.y - from.y;
    float d = mag(vx, vy);
    if (d > 0) {
      float f = (len - d) / (d * 3);
      float dx = f * vx;
      float dy = f * vy;
      to.dx += dx;
      to.dy += dy;
      from.dx -= dx;
      from.dy -= dy;
    }
  }


  void draw() {
    stroke(edgeColor);
    strokeWeight(0.35);
    line(from.x, from.y, to.x, to.y);
  }
}


//NODE

// Code from Visualizing Data, First Edition, Copyright 2008 Ben Fry.
// Based on the GraphLayout example by Sun Microsystems.


class Node {
  float x, y;
  float dx, dy;
  boolean fixed;
  String label;
  int count;
  int taille;


  Node(String label) {
    this.label = label;
    x = width/2;
    y = height/2;
  }


  void increment() {
    count++;
  }


  void relax() {
    float ddx = 0;
    float ddy = 0;

    for (int j = 0; j < nodeCount; j++) {
      Node n = nodes[j];
      if (n != this) {
        float vx = x - n.x;
        float vy = y - n.y;
        float lensq = vx * vx + vy * vy;
        if (lensq == 0) {
          ddx += random(1);
          ddy += random(1);
        }
        else if (lensq < 100*100) {
          ddx += vx / lensq;
          ddy += vy / lensq;
        }
      }
    }
    float dlen = mag(ddx, ddy) / 2;
    if (dlen > 0.00000000000001) {
      dx += ddx / dlen;
      dy += ddy / dlen;
    }
  }


  void update() {
    if (!fixed) {    
      x += constrain(dx, -10, 10);
      y += constrain(dy, -10, 10);

      x = constrain(x, 0, width);
      y = constrain(y, 0, height);
    }
    dx /= 2;
    dy /= 2;
  }


  void draw() {
    fill(nodeColor);
    stroke(0);
    strokeWeight(0.5);
    taille =count;
    taille = constrain(taille, 20, 200);
    ellipse(x, y, taille, taille);
    float w = textWidth(label);

  // if (taille > w+2) {
      fill(0);
      textAlign(CENTER, CENTER);
      text(label, x, y);
   //}
  }
}

// RDF

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

class Rdf {
Model model;
  Rdf() {

    test();
    lister();
    afficheConsole();
  }
  void test() {
    // some definitions
    String personURI    = "http://somewhere/JohnSmith";
    String givenName    = "John";
    String familyName   = "Smith";
    String fullName     = givenName + " " + familyName;
    String personURIMe    = "http://fada-range.appspot.com/DavidFaveris";
    String givenNameMe    = "David";
    String familyNameMe   = "Faveris";
    String fullNameMe     = givenNameMe + " " + familyNameMe;
    // create an empty Model
    model = ModelFactory.createDefaultModel();

    // create the resource
    Resource johnSmith =  model.createResource(personURI);
    Resource davidFaveris =  model.createResource(personURIMe);

    // add the property
    johnSmith.addProperty(VCARD.FN, fullName)
      .addProperty(VCARD.N, model.createResource()
        .addProperty(VCARD.Given, givenName)
        .addProperty(VCARD.Family, familyName));
    ;
    davidFaveris.addProperty(VCARD.FN, fullNameMe)
      .addProperty(VCARD.N, model.createResource()
        .addProperty(VCARD.Given, givenNameMe)
        .addProperty(VCARD.Family, familyNameMe));

    println(johnSmith);
    println(davidFaveris);
    addNode("johnSmith");
    addNode("davidFaveris");

  }


void afficheConsole(){
  model.write(System.out);
}

  void lister() {
    // list the statements in the Model
    StmtIterator iter = model.listStatements();

    // print out the predicate, subject and object of each statement
    while (iter.hasNext ()) {
      Statement stmt      = iter.nextStatement();  // get next statement
      Resource  subject   = stmt.getSubject();     // get the subject
      Property  predicate = stmt.getPredicate();   // get the predicate
      RDFNode   object    = stmt.getObject();      // get the object
addEdge(subject.toString(), object.toString());
        System.out.print("Sujet : "+subject.toString());
      System.out.print(" "+"\tPredicat : " + predicate.toString() + " ");
      if (object instanceof Resource) {
        System.out.print("\tObjet : "+object.toString());
      } 
      else {
        // object is a literal
        System.out.print(" \"" + object.toString() + "\"");
      }

      System.out.println(" .");
    }
    
  }
}

//File

class File {
  File() {
    String lines[] = loadStrings("vcard.rdf");
    println("there are " + lines.length + " lines");
for (int i = 0 ; i < lines.length; i++) {

      lines[i] = lines[i].replaceAll("  ", "");

      //PREFIXES
      lines[i] = lines[i].replaceAll("http://www.semanticweb.org/fada/ontologies/2013/10/smag/monde#", "");
      lines[i] = lines[i].replaceAll("http://www.semanticweb.org/fada/ontologies/2013/10/smag/monde#", "");
      lines[i] = lines[i].replaceAll("http://www.w3.org/2002/07/owl#", "");
      println(lines[i]);
    }
    for (int i = 0; i < lines.length; i++) {
      // Make this phrase lowercase
      //  String line = lines[i].toLowerCase();
      String line = lines[i];
      // Split each phrase into individual words at one or more spaces
      String[] words = splitTokens(line, "|");
 /*     for (int w = 0; w < words.length-1; w=+3) {
        words[w]=words[w].replaceAll(" ", "");
        words[w+2]=words[w+2].replaceAll(" ", "");
        if ((words[w+2]=="<Class>") || (words[w]=="<Class>")) {
          print ("classe");
        }
        else {
          addEdge(words[w], words[w+2]);
          print (words[w+1]+" entre "+words[w]+ " et " + words[w+2]+"\n");
        }
      }
   */ }
  }
}


20/12/2013

L'électronique

Outre les sites généralistes DIY qui pullule,
un site en français fais pour moi référence : http://www.mon-club-elec.fr/pmwiki_mon_club_elec/pmwiki.php?n=MAIN.PCDUINO

je viens également de tomber sur celui-là où il semble y avoir quelques tutoriels : http://www.positron-libre.com/

Plusieurs pistes sont à explorer, le "De base" semblant être la carte de prototypage Arduino, de multiples possibilités sont aujourd'hui offertes, et tous les jours, il y en a de nouvelles : je viens de tomber sur une carte programmable en Javascript : http://www.dragoninnovation.com/projects/22-tessel#js-localscroll-targe

Je projetais d'investir sur la carte Pcduino (minipc avec Ubuntu +Android), pour me faire la main sur le Rover Pcduino (quand j'ai vu qu'ils avaient sorti la V2 avec wifi intégré ! et maintenant Linux aussi sur une carte Arduino ... mais où celà va-t-il nous mener ??

Construire un robot de surveillance avec Pcduino ( doc en pdf ) (Rover PCDuino : traduction en français)
avantages du pcduino : Linux, Android, possibilité d'en faire un serveur Web fournissant un point d'accès Wifi : pas besoin de se connecter à un réseau existant, il fournit son propre réseau ! Autonomie +++

Fabrication des robots

Pour la fabrication des prototypes ou des pièces des robots, on pourra chercher dans tout ce qui est imprimantes 3D. http://3dprintshow.com/paris2013/3d-printshow-paris-2013-full-report/

notamment dans les FABLABS comme ARTILECT à Toulouse, où l'on peut utiliser l'imprimante 3D pour quelques Euros de l'heure.

On peut évidemment s'inspirer des nombreux sites 

19/12/2013

Les vocabulaires RDF , OWL ...

Plus d'infos sur les vocabulaires et Schémas RDF : http://en.wikipedia.org/wiki/RDF_Schema 

Selon les principes du web sémantiques, le mieux est de réutiliser des vocabulaires déjà existants et d'y faire référence. Ci-dessous, vous trouverez les vocabulaires susceptibles d'être utiles, pour nos bases de données :

 En faisant le tour des différents vocabulaires existants,je me rend compte qu'il nous manquera pas mal d'information, il va donc falloir les utiliser, (les traduire ?) et certainement ajouter de nouvelles notions.
Partons de prissma, puisque c'est un vocabulaire représentant des données en fonction d'un contexte mobile, ce vocabulaire pourra être utilisé pour les interfaces Homme-Machine mais également proche de celui d'un vocabulaire qui pourrait être utilisé par un robot, prenant en compte son environnement.


Prissma utilise les vocabulaires suivants : (source : http://ns.inria.fr/prissma/v2/prissma_v2.html)
@prefix : <http://example.org#> .
@prefix prissma: <http://ns.inria.fr/prissma/v2#> . (rdf)
@prefix fresnel: <http://www.w3.org/2004/09/fresnel#> .(core : (owl/xml) (n3), extended : (owl/xml)(n3)
@prefix foaf: <http://xmlns.com/foaf/0.1/> .
@prefix soft: <http://www.w3.org/2007/uwa/context/software.owl#> .
@prefix common: <http://www.w3.org/2007/uwa/context/common.owl#> .
@prefix geo: <http://www.w3.org/2003/01/geo/wgs84_pos#> . 
 
un autre vocabulaire nous sera surement utile : xmlns:doap="http://usefulinc.com/doap/" 
( Description of a Project )@fr Description d'un projet
dans le sens où ça serait bien d'avoir un rdf/schema complet du projet SMAG ! (Hop c'est fait
--> Smag-doap.rdf  avec l'outil DOAP-MATIC
 mais aussi car on peut considérer les intentions des agents /robots comme des projets,
 on pourra certainement utiliser doap pour décrire les intentions,
 les participants à une actions.... ???

Parmi ceux foaf représente une personne, 
deux autres vocabulaires ne sont pas à négliger: 
@PREFIX rdf:   <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
@PREFIX rdfs:   <http://www.w3.org/2000/01/rdf-schema#> .
ce sont même les élements centraux de l'utilisation d'RDF ou d'une ontologie.
un autre essentiel le dublin Core : http://www.yoyodesign.org/doc/dcmi/dcmi-terms/index.html 
 
Voyons ça de plus près ! 
 
 
 
 
 
  • PRISSMA
namespace : http://ns.inria.fr/prissma (rdf-v2)
fonction : représentation des données en fonction d'un contexte mobile (smartphone Android, embarqué dans un véhicule ?...)
documentation : http://wimmics.inria.fr/projects/prissma/
est une extension de Fresnel : http://www.w3.org/2005/04/fresnel-info/
développeur : Lucas Costabello , Fabien Gandon

PB: une erreur pour l'instant à la compilation du PRISSMA-BROWSER : https://github.com/lukostaz/prissma-browser/issues/1

  • SHI3LD
fonction : pour des autorisations en fonction du contexte défini par PRISSMA
documentation :  http://wimmics.inria.fr/projects/shi3ld/


prérequis : nécessite Prissma (voir plus haut) et S4AC  : http://ns.inria.fr/s4ac/ (rdf-v2)

Une interface pour enregistrer de nouvelles informations


  • Une interface Web
http://fada-range.appspot.com/ ## TODO pour l'instant on ne peut y mettre que du texte,il faut structurer la saisie, modifier pour pouvoir enregistrer des triplets (rdf + graph ) une base générale commune, une autre personnelle (privée avec possibilité de partager à un utilisateur particulier, ou à un groupe)
Système de vote pour donner un poids aux assertions et aux relations entre celles-ci.


  • Une Interface Mobile
  • Une interface PC 
Utilisation de Processing



A SUIVRE
Supervision adaptée des objets connectés :

OUTILS
RDF API http://infolab.stanford.edu/~melnik/rdf/api.html

Base de données , ontologie et rdf

Une base de données interne à chaque robot / smartphone avec connexion à des silos de données plus étendus (DBPEDIA...)


  • STOCKAGE DES DONNEES
Il existe plusieurs solutions permettant le stockage des données. les données au format RDF sont toujours composées de trois éléments, cet ensemble de trois éléments est appelé un triplet. L'endroit ou sont stockés les triplets se nomme triplestore ou magasin de données. 

Jena est une api Java permettant la manipulation des données, leur acquisition depuis le web des données, au moyen de requetes Sparql, et son magasin de données  associé est Fuseki ( lien vers JENA-sparql avec des tutoriels en français )
  • LES VOCABULAIRES RDF

nous permettent d'utiliser le web sémantique pour lier les données (d'environnement, de contexte...)
voir les vocabulaires utiles


OUTILS
Conversion d'Uml en ontologie OWL, pour créer les bases de données par défaut ?
http://www.w3.org/wiki/UML_and_RDF
http://topquadrantblog.blogspot.fr/2011/02/converting-uml-models-to-owl-part-1.html

De la méthode

Pour concevoir le système multi-agent, on peut se référer à la méthode Diamond décrite ici :
http://hal.archives-ouvertes.fr/docs/00/18/90/46/PDF/These_Jean-Paul_Jamont_2005.pdf


Plusieurs étapes sont nécessaires si on utilise la méthode Diamond.
Cette méthode permet d'élaborer une documentation complète du Système Multi-agent.
(TODO : il serait utile de développer une application permettant l'automatisation des tâches nécessaires à cette méthode )

Les rubriques de la documentation d'un système multi-agent :



Smag0 - Le projet

Smag l'origine du projet : https://github.com/scenaristeur/brange/wiki

Le projet de départ, c'est pour satisfaire mon fils qui lorsque je lui demandais un jour de ranger sa chambre, voyant son Robosapien que je lui avait acheté me répondit :
"ça serait bien un robot qui range ma chambre"

Evidemment on en a tous (ou presque) rêvé.

Au fil de mes recherches, les choses se mettent petit à petit en place.

Les grands principes dégagés :
- d'ici 15 / 20 ans, les robots risquent de devenir monnaie courante dans nos habitations (voir sur le site d'Imaginove notamment )
- de nombreux bricoleurs / inventeurs tentent dans leur coin de créer des robots à base d'Arduino / Pcduino...
- le système à mettre en place devra :
  1. garantir la sécurité des personnes, des informations et des biens
  2. posséder une architecture de système Multi-agent 
  3. Posséder une interface intuitive et facile pour qu'un enfant puisse s'en service , proposer plusieurs types d'interface ( reconnaissance vocale dans la maison, tactile sur les mobiles, pc...)
  4. utiliser les bases de données distribuées (RDF, OWL, SPARQL...)
  •   pour acquérir des données d'environnement par exemple (l'utilisateur et ses habitudes), des recettes de cuisine, des méthodes, ... -> web sémantique
  • ou pour que chaque robot/agent puisse stocker ses propres informations en local