diff --git a/Modules/RDF/mitkRdfStore.cpp b/Modules/RDF/mitkRdfStore.cpp
index b8e42f0cdc..bd136775a4 100644
--- a/Modules/RDF/mitkRdfStore.cpp
+++ b/Modules/RDF/mitkRdfStore.cpp
@@ -1,338 +1,391 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "mitkRdfStore.h"
 
 #include <iostream>
 
 namespace mitk {
-
-class RdfStorePrivate {
-
-public:
-  RdfStorePrivate();
-  ~RdfStorePrivate();
-};
-
-RdfStore::RdfStore()
-  : m_World(0), m_Storage(0), m_Model(0)
-{
-  // SetUp base prefixes
-  m_Prefixes["rdf"] = RdfUri("http://www.w3.org/1999/02/22-rdf-syntax-ns#");
-  m_Prefixes["rdfs"] = RdfUri("http://www.w3.org/2000/01/rdf-schema#");
-  m_Prefixes["xsd"] = RdfUri("http://www.w3.org/2001/XMLSchema#");
-  m_Prefixes["owl"] = RdfUri("http://www.w3.org/2002/07/owl#");
-
-  // SetUp new store
-  CleanUp();
-}
-
-RdfStore::~RdfStore()
-{
-  if(m_Model)
-    librdf_free_model(m_Model);
-  if(m_Storage)
-    librdf_free_storage(m_Storage);
-  if(m_World)
-    librdf_free_world(m_World);
-}
-
-void RdfStore::SetBaseUri(RdfUri uri)
-{
-  m_BaseUri = uri;
-  m_Prefixes[""] = m_BaseUri;
-}
-
-RdfUri RdfStore::GetBaseUri()
-{
-  return m_BaseUri;
-}
-
-void RdfStore::AddPrefix(std::string prefix, RdfUri uri)
-{
-  m_Prefixes[prefix] = uri;
-}
-
-void RdfStore::CleanUp()
-{
-  // CleanUp old Store if there is one
-  if(m_Model)
-    librdf_free_model(m_Model);
-  if(m_Storage)
-    librdf_free_storage(m_Storage);
-  if(m_World)
-    librdf_free_world(m_World);
-
-  // SetUp new Store
-  m_World = librdf_new_world();
-  librdf_world_open(m_World);
-  m_Storage = librdf_new_storage(m_World, "memory", 0, 0);
-  m_Model = librdf_new_model(m_World, m_Storage, 0);
-}
-
-bool RdfStore::Add(RdfTriple triple)
-{
-  librdf_statement* statement = RdfTripleToStatement(triple);
-
-  if (!CheckComplete(statement))
+  class RdfStorePrivate {
+  public:
+    RdfStorePrivate();
+    ~RdfStorePrivate();
+  };
+
+  RdfStore::RdfStore()
+    : m_World(0), m_Storage(0), m_Model(0)
   {
-    librdf_free_statement(statement);
-    return false;
+    // SetUp base prefixes
+    m_Prefixes["rdf"] = RdfUri("http://www.w3.org/1999/02/22-rdf-syntax-ns#");
+    m_Prefixes["rdfs"] = RdfUri("http://www.w3.org/2000/01/rdf-schema#");
+    m_Prefixes["xsd"] = RdfUri("http://www.w3.org/2001/XMLSchema#");
+    m_Prefixes["owl"] = RdfUri("http://www.w3.org/2002/07/owl#");
+
+    // SetUp new store
+    CleanUp();
   }
 
-  // Store already contains statement
-  if (Contains(triple)) return false;
+  RdfStore::~RdfStore()
+  {
+    if(m_Model)
+      librdf_free_model(m_Model);
+    if(m_Storage)
+      librdf_free_storage(m_Storage);
+    if(m_World)
+      librdf_free_world(m_World);
+  }
 
-  if (librdf_model_add_statement(m_Model, statement) != 0) {
-    librdf_free_statement(statement);
-    return false;
+  void RdfStore::SetBaseUri(RdfUri uri)
+  {
+    m_BaseUri = uri;
+    //m_Prefixes[""] = RdfUri(m_BaseUri.ToString()+"#");
   }
-  else
+
+  RdfUri RdfStore::GetBaseUri()
   {
-    librdf_free_statement(statement);
-    return true;
+    return m_BaseUri;
   }
-}
 
-bool RdfStore::Remove(RdfTriple triple)
-{
-  librdf_statement* statement = RdfTripleToStatement(triple);
+  void RdfStore::AddPrefix(std::string prefix, RdfUri uri)
+  {
+    m_Prefixes[prefix] = uri;
+  }
 
-  if (!CheckComplete(statement))
+  void RdfStore::CleanUp()
   {
-    librdf_free_statement(statement);
-    return false;
+    // CleanUp old Store if there is one
+    if(m_Model)
+      librdf_free_model(m_Model);
+    if(m_Storage)
+      librdf_free_storage(m_Storage);
+    if(m_World)
+      librdf_free_world(m_World);
+
+    // SetUp new Store
+    m_World = librdf_new_world();
+    librdf_world_open(m_World);
+    m_Storage = librdf_new_storage(m_World, "memory", 0, 0);
+    m_Model = librdf_new_model(m_World, m_Storage, 0);
   }
 
-  // Store does not contain statement
-  if (!Contains(triple)) return false;
+  bool RdfStore::Add(RdfTriple triple)
+  {
+    librdf_statement* statement = RdfTripleToStatement(triple);
 
-  if (librdf_model_remove_statement(m_Model, statement) != 0) {
-    librdf_free_statement(statement);
-    return false;
+    if (!CheckComplete(statement))
+    {
+      librdf_free_statement(statement);
+      return false;
+    }
+
+    // Store already contains statement
+    if (Contains(triple)) return false;
+
+    if (librdf_model_add_statement(m_Model, statement) != 0) {
+      librdf_free_statement(statement);
+      return false;
+    }
+    else
+    {
+      librdf_free_statement(statement);
+      return true;
+    }
   }
-  else
+
+  bool RdfStore::Remove(RdfTriple triple)
   {
-    librdf_free_statement(statement);
-    return true;
-  }
-  return false;
-}
+    librdf_statement* statement = RdfTripleToStatement(triple);
+
+    if (!CheckComplete(statement))
+    {
+      librdf_free_statement(statement);
+      return false;
+    }
 
-bool RdfStore::Contains(RdfTriple triple)
-{
-  librdf_statement* statement = RdfTripleToStatement(triple);
+    // Store does not contain statement
+    if (!Contains(triple)) return false;
 
-  // if 0 there is no triple
-  if (librdf_model_contains_statement(m_Model, statement) == 0) {
-    librdf_free_statement(statement);
+    if (librdf_model_remove_statement(m_Model, statement) != 0) {
+      librdf_free_statement(statement);
+      return false;
+    }
+    else
+    {
+      librdf_free_statement(statement);
+      return true;
+    }
     return false;
   }
-  else
+
+  bool RdfStore::Contains(RdfTriple triple)
   {
-    librdf_free_statement(statement);
-    return true;
+    librdf_statement* statement = RdfTripleToStatement(triple);
+
+    // if 0 there is no triple
+    if (librdf_model_contains_statement(m_Model, statement) == 0) {
+      librdf_free_statement(statement);
+      return false;
+    }
+    else
+    {
+      librdf_free_statement(statement);
+      return true;
+    }
+    return false;
   }
-  return false;
-}
 
-void RdfStore::Save(std::string filename, std::string format)
-{
-  if (format == "") format = "turtle";
+  RdfStore::ResultMap RdfStore::Query(std::string sparqlQuery)
+  {
+    RdfStore::ResultMap resultMap;
+    std::string completeQuery;
+
+    for (PrefixMap::const_iterator i = m_Prefixes.begin(); i != m_Prefixes.end(); i++)
+    {
+      completeQuery += "PREFIX " + i->first + ": " + "<" + i->second.ToString() + "> ";
+    }
+    completeQuery += sparqlQuery;
 
-  librdf_uri* baseUri = RdfUriToLibRdfUri(m_BaseUri);
-  librdf_serializer* s = librdf_new_serializer(m_World, format.c_str(), 0, 0);
+    librdf_query* rdfQuery = librdf_new_query(m_World, "sparql", 0, (const unsigned char*) completeQuery.c_str(), 0);
 
-  for (PrefixMap::const_iterator i = m_Prefixes.begin(); i != m_Prefixes.end(); i++)
-  {
-    librdf_serializer_set_namespace(s, RdfUriToLibRdfUri(i->second), i->first.c_str());
-  }
-  // May this is not relevant
-  int error = librdf_serializer_set_namespace(s, librdf_new_uri(m_World,
-    (const unsigned char*) m_BaseUri.ToString().append("#").c_str()), ""); //FAILED
+    if (!rdfQuery) return resultMap;
 
-  if (error != 0) std::cout << "________FAIL________" << std::endl;
+    librdf_query_results* results = librdf_query_execute(rdfQuery, m_Model);
 
-  FILE* f = fopen(filename.c_str(), "w+");
+    if (!results)
+    {
+      librdf_free_query(rdfQuery);
+      return resultMap;
+    }
+    // TODO CHANGE TYPE OF QUERY
+    if (!librdf_query_results_is_bindings(results))
+    {
+      librdf_free_query_results(results);
+      librdf_free_query(rdfQuery);
+      return resultMap;
+    }
 
-  librdf_serializer_serialize_model_to_file_handle(s, f, baseUri, m_Model);
+    while (!librdf_query_results_finished(results))
+    {
+      int count = librdf_query_results_get_bindings_count(results);
 
-  librdf_free_serializer(s);
-  librdf_free_uri(baseUri);
-  fclose(f);
-}
+      for (int i = 0; i < count; ++i)
+      {
+        const char *name = librdf_query_results_get_binding_name(results, i);
 
-void RdfStore::Import(std::string url, std::string format)
-{
-  std::string baseUri = m_BaseUri.ToString();
+        if (!name) continue;
 
-  if (baseUri.empty())
-  {
-    baseUri = url;
-    SetBaseUri(RdfUri(baseUri));
-  }
+        std::string key = name;
 
-  if (format == "")
-  {
-    format= "turtle";
-  }
+        librdf_node *node = librdf_query_results_get_binding_value(results, i);
 
-  // Redland uses file paths like file:D:/home/readme.txt
-  librdf_uri* uri = librdf_new_uri(m_World, (const unsigned char*) url.c_str());
-  librdf_uri* libRdfBaseUri = librdf_new_uri(m_World, (const unsigned char*) baseUri.c_str());
+        resultMap[key] = LibRdfNodeToRdfNode(node);
+      }
 
-  librdf_parser* p = librdf_new_parser(m_World, format.c_str(), 0, 0);
+      librdf_query_results_next(results);
+    }
 
-  if (librdf_parser_parse_into_model(p, uri, libRdfBaseUri, m_Model) != 0 )
-  {
-    librdf_free_parser(p);
-    std::cout << "Parsing failed.";
-    return;
+    librdf_free_query_results(results);
+    librdf_free_query(rdfQuery);
+
+    return resultMap;
   }
 
-  int namespaces = librdf_parser_get_namespaces_seen_count(p);
+  void RdfStore::Save(std::string filename, std::string format)
+  {
+    if (format == "") format = "turtle";
 
-  for (int i = 0; i < namespaces; i++) {
-    const char* prefixChar = librdf_parser_get_namespaces_seen_prefix(p, i);
+    librdf_uri* baseUri = RdfUriToLibRdfUri(m_BaseUri);
+    librdf_serializer* s = librdf_new_serializer(m_World, format.c_str(), 0, 0);
 
-    if ( !prefixChar ) continue;
+    for (PrefixMap::const_iterator i = m_Prefixes.begin(); i != m_Prefixes.end(); i++)
+    {
+      librdf_serializer_set_namespace(s, RdfUriToLibRdfUri(i->second), i->first.c_str());
+    }
+    // May this is not relevant
+    //int error = librdf_serializer_set_namespace(s, librdf_new_uri(m_World,
+    //  (const unsigned char*) m_BaseUri.ToString().append("#").c_str()), ""); //FAILED FAIL TODO
 
-    std::string prefix = prefixChar;
-    RdfUri uri = LibRdfUriToRdfUri(librdf_parser_get_namespaces_seen_uri(p, i));
+    //if (error != 0) std::cout << "________FAIL________" << std::endl;
 
-    if (uri == RdfUri()) return;
+    FILE* f = fopen(filename.c_str(), "w+");
 
-    RdfStore::PrefixMap::iterator it = m_Prefixes.find(prefix);
+    librdf_serializer_serialize_model_to_file_handle(s, f, baseUri, m_Model);
 
-    // map iterator is equal to iterator-end so it is not already added
-    if (it == m_Prefixes.end()) {
-      AddPrefix(prefix, uri);
-    }
+    librdf_free_serializer(s);
+    librdf_free_uri(baseUri);
+    fclose(f);
   }
-}
-
-/*****************************************************************************
- ********************************** Private **********************************
- *****************************************************************************/
-
-bool RdfStore::CheckComplete(librdf_statement* statement)
-{
-  if (librdf_statement_is_complete(statement) != 0) return true;
-  else return false;
-}
-
-librdf_statement* RdfStore::RdfTripleToStatement(RdfTriple triple)
-{
-  librdf_node* subject = RdfNodeToLibRdfNode(triple.GetSubject());
-  librdf_node* predicate = RdfNodeToLibRdfNode(triple.GetPredicate());
-  librdf_node* object = RdfNodeToLibRdfNode(triple.GetObject());
-
-  librdf_statement* statement = librdf_new_statement_from_nodes(m_World, subject, predicate, object);
-  if(!statement) return 0;
-  return statement;
-}
-
-librdf_node* RdfStore::RdfNodeToLibRdfNode(RdfNode node)
-{
-  librdf_node* newNode = 0;
-
-  switch (node.type)
+
+  void RdfStore::Import(std::string url, std::string format)
   {
-  case RdfNode::NOTHING:
-    break;
-  case RdfNode::BLANK:
-    newNode = librdf_new_node_from_blank_identifier(m_World, (const unsigned char*) node.value.c_str());
-    break;
-  case RdfNode::LITERAL:
+    std::string baseUri = m_BaseUri.ToString();
+
+    if (baseUri.empty())
     {
-      if (node.datatype != RdfUri())
-      {
-        librdf_uri* typeUri = RdfUriToLibRdfUri(node.datatype);
-        newNode = librdf_new_node_from_typed_literal(m_World, (const unsigned char*) node.value.c_str(), 0, typeUri);
-      }
-      else
-      {
-        newNode = librdf_new_node_from_literal(m_World, (const unsigned char*) node.value.c_str(), 0, 0);
+      baseUri = url;
+      SetBaseUri(RdfUri(baseUri));
+    }
+
+    if (format == "")
+    {
+      format= "turtle";
+    }
+
+    // Redland uses file paths like file:D:/home/readme.txt
+    librdf_uri* uri = librdf_new_uri(m_World, (const unsigned char*) url.c_str());
+    librdf_uri* libRdfBaseUri = librdf_new_uri(m_World, (const unsigned char*) baseUri.c_str());
+
+    librdf_parser* p = librdf_new_parser(m_World, format.c_str(), 0, 0);
+
+    if (librdf_parser_parse_into_model(p, uri, libRdfBaseUri, m_Model) != 0 )
+    {
+      librdf_free_parser(p);
+      std::cout << "Parsing failed.";
+      return;
+    }
+
+    int namespaces = librdf_parser_get_namespaces_seen_count(p);
+
+    for (int i = 0; i < namespaces; i++) {
+      const char* prefixChar = librdf_parser_get_namespaces_seen_prefix(p, i);
+
+      if ( !prefixChar ) continue;
+
+      std::string prefix = prefixChar;
+      RdfUri uri = LibRdfUriToRdfUri(librdf_parser_get_namespaces_seen_uri(p, i));
+
+      if (uri == RdfUri()) return;
+
+      RdfStore::PrefixMap::iterator it = m_Prefixes.find(prefix);
+
+      // map iterator is equal to iterator-end so it is not already added
+      if (it == m_Prefixes.end()) {
+        AddPrefix(prefix, uri);
       }
     }
-    break;
-  case RdfNode::URI:
-    newNode = librdf_new_node_from_uri( m_World, librdf_new_uri(m_World, (const unsigned char*) node.value.c_str()) );
-    break;
-  default:
-    break;
   }
-  return newNode;
-}
 
-librdf_uri* RdfStore::RdfUriToLibRdfUri(RdfUri uri)
-{
-  librdf_uri* libUri = librdf_new_uri(m_World, (const unsigned char*) uri.ToString().c_str());
-  if (!libUri) return 0;
-  return libUri;
-}
+  /*****************************************************************************
+  ********************************** Private **********************************
+  *****************************************************************************/
 
-RdfTriple RdfStore::StatementToRdfTriple(librdf_statement* statement)
-{
-  librdf_node *subject = librdf_statement_get_subject(statement);
-  librdf_node *predicate = librdf_statement_get_predicate(statement);
-  librdf_node *object = librdf_statement_get_object(statement);
+  bool RdfStore::CheckComplete(librdf_statement* statement)
+  {
+    if (librdf_statement_is_complete(statement) != 0) return true;
+    else return false;
+  }
 
-  RdfTriple triple(LibRdfNodeToRdfNode(subject),
-    LibRdfNodeToRdfNode(predicate),
-    LibRdfNodeToRdfNode(object));
+  librdf_statement* RdfStore::RdfTripleToStatement(RdfTriple triple)
+  {
+    librdf_node* subject = RdfNodeToLibRdfNode(triple.GetSubject());
+    librdf_node* predicate = RdfNodeToLibRdfNode(triple.GetPredicate());
+    librdf_node* object = RdfNodeToLibRdfNode(triple.GetObject());
 
-  return triple;
-}
+    librdf_statement* statement = librdf_new_statement_from_nodes(m_World, subject, predicate, object);
+    if(!statement) return 0;
+    return statement;
+  }
 
-RdfNode RdfStore::LibRdfNodeToRdfNode(librdf_node* node)
-{
-  RdfNode mitkNode;
+  librdf_node* RdfStore::RdfNodeToLibRdfNode(RdfNode node)
+  {
+    librdf_node* newNode = 0;
 
-  if (!node) return 0;
+    switch (node.type)
+    {
+    case RdfNode::NOTHING:
+      break;
+    case RdfNode::BLANK:
+      newNode = librdf_new_node_from_blank_identifier(m_World, (const unsigned char*) node.value.c_str());
+      break;
+    case RdfNode::LITERAL:
+      {
+        if (node.datatype != RdfUri())
+        {
+          librdf_uri* typeUri = RdfUriToLibRdfUri(node.datatype);
+          newNode = librdf_new_node_from_typed_literal(m_World, (const unsigned char*) node.value.c_str(), 0, typeUri);
+        }
+        else
+        {
+          newNode = librdf_new_node_from_literal(m_World, (const unsigned char*) node.value.c_str(), 0, 0);
+        }
+      }
+      break;
+    case RdfNode::URI:
+      newNode = librdf_new_node_from_uri( m_World, librdf_new_uri(m_World, (const unsigned char*) node.value.c_str()) );
+      break;
+    default:
+      break;
+    }
+    return newNode;
+  }
 
-  if (librdf_node_is_resource(node))
+  librdf_uri* RdfStore::RdfUriToLibRdfUri(RdfUri uri)
   {
-    mitkNode.type = RdfNode::URI;
-    librdf_uri *uri = librdf_node_get_uri(node);
-    mitkNode.value = LibRdfUriToRdfUri(uri).ToString();
+    librdf_uri* libUri = librdf_new_uri(m_World, (const unsigned char*) uri.ToString().c_str());
+    if (!libUri) return 0;
+    return libUri;
   }
-  else if (librdf_node_is_literal(node))
+
+  RdfTriple RdfStore::StatementToRdfTriple(librdf_statement* statement)
   {
-    mitkNode.type = RdfNode::LITERAL;
-    std::string value = (const char*) librdf_node_get_literal_value(node);
-    if (!value.empty()) mitkNode.value = value;
-    librdf_uri* typeUri = librdf_node_get_literal_value_datatype_uri(node);
-    if (typeUri) mitkNode.datatype = LibRdfUriToRdfUri(typeUri);
+    librdf_node *subject = librdf_statement_get_subject(statement);
+    librdf_node *predicate = librdf_statement_get_predicate(statement);
+    librdf_node *object = librdf_statement_get_object(statement);
+
+    RdfTriple triple(LibRdfNodeToRdfNode(subject),
+      LibRdfNodeToRdfNode(predicate),
+      LibRdfNodeToRdfNode(object));
+
+    return triple;
   }
-  else if (librdf_node_is_blank(node))
+
+  RdfNode RdfStore::LibRdfNodeToRdfNode(librdf_node* node)
   {
-    mitkNode.type = RdfNode::BLANK;
-    std::string str = (const char*) librdf_node_get_blank_identifier(node);
-    if (!str.empty()) mitkNode.value = str;
-  }
-  return mitkNode;
-}
+    RdfNode mitkNode;
+
+    if (!node) return 0;
 
-RdfUri RdfStore::LibRdfUriToRdfUri(librdf_uri* uri)
-{
-  std::string str = (const char*) librdf_uri_as_string(uri);
-  if (!str.empty()) return RdfUri(str);
+    if (librdf_node_is_resource(node))
+    {
+      mitkNode.type = RdfNode::URI;
+      librdf_uri *uri = librdf_node_get_uri(node);
+      mitkNode.value = LibRdfUriToRdfUri(uri).ToString();
+    }
+    else if (librdf_node_is_literal(node))
+    {
+      mitkNode.type = RdfNode::LITERAL;
+      std::string value = (const char*) librdf_node_get_literal_value(node);
+      if (!value.empty()) mitkNode.value = value;
+      librdf_uri* typeUri = librdf_node_get_literal_value_datatype_uri(node);
+      if (typeUri) mitkNode.datatype = LibRdfUriToRdfUri(typeUri);
+    }
+    else if (librdf_node_is_blank(node))
+    {
+      mitkNode.type = RdfNode::BLANK;
+      std::string str = (const char*) librdf_node_get_blank_identifier(node);
+      if (!str.empty()) mitkNode.value = str;
+    }
+    return mitkNode;
+  }
 
-  return RdfUri();
-}
+  RdfUri RdfStore::LibRdfUriToRdfUri(librdf_uri* uri)
+  {
+    std::string str = (const char*) librdf_uri_as_string(uri);
+    if (!str.empty()) return RdfUri(str);
 
+    return RdfUri();
+  }
 } // end of namespace mitk
diff --git a/Modules/RDF/mitkRdfStore.h b/Modules/RDF/mitkRdfStore.h
index 97080d98ae..7107143ffc 100644
--- a/Modules/RDF/mitkRdfStore.h
+++ b/Modules/RDF/mitkRdfStore.h
@@ -1,75 +1,80 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #ifndef MITKRDFSTORE_H
 #define MITKRDFSTORE_H
 
 #include <MitkRDFExports.h>
 #include <map>
 
 #include <redland.h>
 
 #include "mitkRdfTriple.h"
 
 namespace mitk {
 
 class MitkRDF_EXPORT RdfStore
 {
 public:
+
+  typedef std::map<std::string, RdfNode> ResultMap;
+  typedef std::map<std::string, RdfUri> PrefixMap;
+
   RdfStore();
   ~RdfStore();
 
   void SetBaseUri(RdfUri uri);
   RdfUri GetBaseUri();
 
   void AddPrefix(std::string prefix, RdfUri uri);
   void CleanUp();
 
   bool Add(RdfTriple triple);
   bool Remove(RdfTriple triple);
 
   bool Contains(RdfTriple triple);
+  ResultMap Query(std::string query);
 
   // Supported formats are: "ntriples", "turtle"(default), "nquads"
   void Save(std::string filename, std::string format = "");
 
   // Supported formats are: "ntriples", "turtle"(default), "nquads"
   void Import(std::string url, std::string format = "");
 
 private:
+
   RdfUri m_BaseUri;
 
-  typedef std::map<std::string, RdfUri> PrefixMap;
   PrefixMap m_Prefixes;
 
   librdf_model* m_Model;
   librdf_storage* m_Storage;
   librdf_world* m_World;
 
   librdf_statement* RdfTripleToStatement(RdfTriple triple);
   librdf_node* RdfNodeToLibRdfNode(RdfNode node);
   librdf_uri* RdfUriToLibRdfUri(RdfUri uri);
 
   RdfTriple StatementToRdfTriple(librdf_statement* statement);
   RdfNode LibRdfNodeToRdfNode(librdf_node* node);
   RdfUri LibRdfUriToRdfUri(librdf_uri* uri);
 
   bool CheckComplete(librdf_statement* statement);
 };
 
 }
 
 #endif // MITKRDFSTORE_H
diff --git a/Modules/RDF/mitkRdfUri.cpp b/Modules/RDF/mitkRdfUri.cpp
index f5fd2be4e2..86fc30cfdc 100644
--- a/Modules/RDF/mitkRdfUri.cpp
+++ b/Modules/RDF/mitkRdfUri.cpp
@@ -1,52 +1,50 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "mitkRdfUri.h"
 
 #include <string>
 
 namespace mitk {
-
-RdfUri::RdfUri()
-{
-}
-
-RdfUri::RdfUri(std::string uri)
-  : m_Uri(uri)
-{
-}
-
-RdfUri::~RdfUri()
-{
-}
-
-std::string RdfUri::ToString()
-{
-  return m_Uri;
-}
-
-bool RdfUri::operator==(const RdfUri &u) const
-{
-  if (this->m_Uri.compare(u.m_Uri) != 0) return false;
-  return true;
-}
-
-bool RdfUri::operator!=(const RdfUri &u) const
-{
-  return !operator==(u);
-}
-
+  RdfUri::RdfUri()
+  {
+  }
+
+  RdfUri::RdfUri(std::string uri)
+    : m_Uri(uri)
+  {
+  }
+
+  RdfUri::~RdfUri()
+  {
+  }
+
+  std::string RdfUri::ToString() const
+  {
+    return m_Uri;
+  }
+
+  bool RdfUri::operator==(const RdfUri &u) const
+  {
+    if (this->m_Uri.compare(u.m_Uri) != 0) return false;
+    return true;
+  }
+
+  bool RdfUri::operator!=(const RdfUri &u) const
+  {
+    return !operator==(u);
+  }
 } // end of namespace mitk
diff --git a/Modules/RDF/mitkRdfUri.h b/Modules/RDF/mitkRdfUri.h
index 09394186a0..470ae6a3f6 100644
--- a/Modules/RDF/mitkRdfUri.h
+++ b/Modules/RDF/mitkRdfUri.h
@@ -1,45 +1,45 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #ifndef MITKRDFURI_H
 #define MITKRDFURI_H
 
 #include <MitkRDFExports.h>
 
 #include <string>
 
 namespace mitk {
 
 class MitkRDF_EXPORT RdfUri
 {
 public:
   RdfUri();
   explicit RdfUri(std::string uri);
 
   virtual ~RdfUri();
 
-  std::string ToString();
+  std::string ToString() const;
 
   bool operator==(const RdfUri &u) const;
   bool operator!=(const RdfUri &u) const;
 
 private:
   std::string m_Uri;
 };
 
 }
 
 #endif // MITKRDFURI_H
diff --git a/Plugins/org.mitk.gui.qt.rdftriplestore/src/internal/QmitkRdfTriplestoreView.cpp b/Plugins/org.mitk.gui.qt.rdftriplestore/src/internal/QmitkRdfTriplestoreView.cpp
index 1dc5ea77d1..1fa7f96278 100644
--- a/Plugins/org.mitk.gui.qt.rdftriplestore/src/internal/QmitkRdfTriplestoreView.cpp
+++ b/Plugins/org.mitk.gui.qt.rdftriplestore/src/internal/QmitkRdfTriplestoreView.cpp
@@ -1,134 +1,237 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 // Qmitk
 #include "QmitkRdfTriplestoreView.h"
 
 // Qt
 #include <QMessageBox>
 #include <qcompleter.h>
 
 // MitkRdf
 #include <mitkRdfStore.h>
 
+// NodePredicateNot
+//#include <mitkNodePredicateDataType.h>
+#include <mitkNodePredicateProperty.h>
+//#include <mitkNodePredicateAnd.h>
+#include <mitkNodePredicateNot.h>
+
+// GDCM
+#include <gdcmUUIDGenerator.h>
+
 const std::string QmitkRdfTriplestoreView::VIEW_ID = "org.mitk.views.rdftriplestore";
 
 typedef mitk::RdfStore Store;
 typedef mitk::RdfTriple Triple;
 typedef mitk::RdfNode Node;
 typedef mitk::RdfUri Uri;
 
 void QmitkRdfTriplestoreView::SetFocus()
 {
   //m_Controls.buttonPerformGenerate->setFocus();
 }
 
 void QmitkRdfTriplestoreView::CreateQtPartControl( QWidget *parent )
 {
   // create GUI widgets from the Qt Designer's .ui file
   m_Controls.setupUi( parent );
-  connect( m_Controls.buttonPerformGenerate, SIGNAL(clicked()), this, SLOT(GenerateRdfFile()) );
-  connect( m_Controls.buttonPerformImport, SIGNAL(clicked()), this, SLOT(ImportRdfFile()) );
 
   m_Controls.lineEditDataNode->setEnabled( false );
   m_Controls.comboBoxProperty->setAutoCompletionCaseSensitivity(Qt::CaseInsensitive);
   m_Controls.comboBoxProperty->setAutoCompletion(true);
   m_Controls.comboBoxProperty->setEditable(false);
 
-  QStringList s;
-  s << "";
-  s << "hasA";
-  m_Controls.comboBoxProperty->addItems(s);
+  //QStringList s;
+  //s << "";
+  //s << "hasA";
+  //m_Controls.comboBoxProperty->addItems(s);
   m_Controls.comboBoxProperty->addItem("title");
   m_Controls.comboBoxProperty->addItem("source");
   m_Controls.comboBoxProperty->addItem("format");
+
+  // Set up the Triplestore
+  m_Store.SetBaseUri(Uri("file:C:/Users/knorr/Desktop/BaseOntologyMitk.rdf"));
+  m_Store.Import("file:D:/home/knorr/builds/tripleStore/Ontologies/dcterms.ttl");
+
+  connect( m_Controls.buttonPerformGenerate, SIGNAL(clicked()), this, SLOT(GenerateRdfFile()) );
+  connect( m_Controls.buttonPerformImport, SIGNAL(clicked()), this, SLOT(ImportRdfFile()) );
+  connect( m_Controls.buttonDataStorageToTriples, SIGNAL(clicked()), this, SLOT(DataStorageToTriples()) );
 }
 
 void QmitkRdfTriplestoreView::OnSelectionChanged( berry::IWorkbenchPart::Pointer /*source*/,
                                                  const QList<mitk::DataNode::Pointer>& nodes )
 {
   // iterate all selected objects, adjust warning visibility
   foreach( mitk::DataNode::Pointer node, nodes )
   {
     if( node.IsNotNull() )
     {
       m_Controls.labelWarning->setVisible( false );
       m_Controls.widgetAddTriple->setEnabled( true );
       m_Controls.lineEditDataNode->setText(QString(node->GetName().c_str()));
       //m_Controls.lineEditProperty->setText(QString(node->GetProperty("path")->GetValueAsString().c_str()));
 
-      for( mitk::PropertyList::PropertyMap::const_iterator i = node->GetPropertyList()->GetMap()->begin();
-        i != node->GetPropertyList()->GetMap()->end(); i++ )
+      for( mitk::PropertyList::PropertyMap::const_iterator i = node->GetData()->GetPropertyList()->GetMap()->begin();
+        i != node->GetData()->GetPropertyList()->GetMap()->end(); i++ )
       {
         //MITK_INFO << i->first << " " << i->second->GetValueAsString();
       }
+
       return;
     }
   }
 
   m_Controls.labelWarning->setVisible( true );
   m_Controls.widgetAddTriple->setEnabled( false );
 }
 
 void QmitkRdfTriplestoreView::GenerateRdfFile()
 {
   // Create a new Store
   mitk::RdfStore store;
 
   // Create a new base URI for the store and set it into the store
   std::string base = "http://www.mitk.org/BaseOntology";
   mitk::RdfUri baseUri(base);
 
   store.SetBaseUri(baseUri);
   store.Import("file:C:/Users/knorr/Desktop/BaseOntologyMitk.rdf");
+  store.AddPrefix("bomrdf", Uri("file:C:/Users/knorr/Desktop/BaseOntologyMitk.rdf"));
+  store.AddPrefix("sfm", Uri("file:C:/Users/knorr/Desktop/storeFromMitk.rdf"));
 
   // Create some nodes
-  mitk::RdfNode project1(mitk::RdfUri("Project1"));
-  mitk::RdfNode subject1(mitk::RdfUri("Subject1"));
+  mitk::RdfNode project1(mitk::RdfUri("sfm:Project1"));
+  mitk::RdfNode subject1(mitk::RdfUri("sfm:Subject1"));
+  mitk::RdfNode proj(mitk::RdfUri("bomrdf:Project"));
+  mitk::RdfNode subj(mitk::RdfUri("bomrdf:Subject"));
 
   // Create some predicate(/property) nodes
-  mitk::RdfNode hasA(mitk::RdfUri("hasA"));
-  mitk::RdfNode name(mitk::RdfUri("name"));
+  mitk::RdfNode hasA(mitk::RdfUri("bomrdf:has"));
+  mitk::RdfNode name(mitk::RdfUri("bomrdf:name"));
+  mitk::RdfNode a(mitk::RdfUri("rdf:type"));
 
   // Create some triples
+
   mitk::RdfTriple t1(project1, hasA, subject1);
-  mitk::RdfTriple t2(project1, name, mitk::RdfNode("MyProject"));
+  mitk::RdfTriple t2(project1, name, "MyProject");
+  Triple t3(project1, a, proj);
+  Triple t4(subject1, a, subj);
+  Triple t5(subject1, name, "MySubject");
 
   // Add triples to store
   store.Add(t1);
-  store.Add(t1);
+  store.Add(t3);
   store.Add(t2);
+  store.Add(t4);
+  store.Add(t5);
 
   // Save the store in a local path
   store.Save("C:/Users/knorr/Desktop/storeFromMitk.rdf");
+
+  //std::string query = "SELECT ?x WHERE {?x bomrdf:name [] .}";
+
+  //Store::ResultMap map = store.Query(query);
+  //for (Store::ResultMap::const_iterator i = map.begin(); i != map.end(); i++)
+  //{
+  //  MITK_INFO << i->first << " " << i->second.value << " " << i->second.type << " " << i->second.datatype;
+  //}
+
   store.CleanUp();
 }
 
 void QmitkRdfTriplestoreView::ImportRdfFile()
 {
   Store store;
   //store.SetBaseUri(Uri("http://mitk.org/wiki/MITK"));
   store.Import("file:C:/Users/knorr/Desktop/BaseOntologyMitk.rdf");
-  store.Import("file:C:/Users/knorr/Desktop/BaseOntologyMITK.owl");
-  //store.Import("http://dublincore.org/documents/2012/06/14/dcmi-terms/?v=elements#");
-
+  //store.Import("http://dublincore.org/documents/2012/06/14/dcmi-terms/?v=elements");
+  //store.AddPrefix("bomowl", Uri("file:C:/Users/knorr/Desktop/BaseOntologyMitk.owl#"));
 
   store.Save("C:/Users/knorr/Desktop/storeFromMitkWithDC.rdf");
+
+  //std::string query = "SELECT ?x FROM <file:C:/Users/knorr/Desktop/storeFromMitkWithDC.rdf> WHERE {?x dc:title ?title .}";
+
+  //Store::ResultMap map = store.Query(query);
+  //for (Store::ResultMap::const_iterator i = map.begin(); i != map.end(); i++)
+  //{
+  //  MITK_INFO << i->first << " " << i->second.value << " " << i->second.type << " " << i->second.datatype;
+  //}
+}
+
+void QmitkRdfTriplestoreView::DataStorageToTriples()
+{
+  gdcm::UUIDGenerator generator;
+
+  // Take all BaseData nodes but dont take helper objects
+  mitk::NodePredicateNot::Pointer isNotHelperObject =
+    mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("helper object"));
+  //mitk::TNodePredicateDataType<mitk::BaseData>::Pointer isBaseData =
+  //  mitk::TNodePredicateDataType<mitk::BaseData>::New();
+  //mitk::NodePredicateAnd::Pointer isNotHelperButBaseData =
+  //  mitk::NodePredicateAnd::New( isBaseData, isNotHelperObject );
+
+  mitk::DataStorage::SetOfObjects::ConstPointer nodeContainer = GetDataStorage()->GetSubset(isNotHelperObject);
+
+  for( mitk::DataStorage::SetOfObjects::ConstIterator iter = nodeContainer->Begin();
+    iter != nodeContainer->End(); iter++ )
+  {
+    const mitk::DataNode::Pointer node = iter->Value();
+
+    if (!node->GetData()) continue;
+
+    std::string name = node->GetProperty("name")->GetValueAsString();
+
+    //const mitk::PropertyList::PropertyMap* map = node->GetData()->GetPropertyList()->GetMap();
+    //for (mitk::PropertyList::PropertyMap::const_iterator i = map->begin(); i != map->end(); i++)
+    //{
+    //  MITK_INFO << i->first << " " << i->second;
+    //}
+
+    // Get the parent of a DataNode
+    mitk::DataStorage::SetOfObjects::ConstPointer sourceContainer = GetDataStorage()->GetSources(iter->Value(), isNotHelperObject);
+
+    for( mitk::DataStorage::SetOfObjects::ConstIterator sources = nodeContainer->Begin();
+      sources != nodeContainer->End(); sources++ )
+    {
+      const mitk::DataNode::Pointer sourceNode = sources->Value();
+
+      if ( sourceNode == node || sourceNode->GetData() ) continue;
+
+      // TODO add to triplestore
+    }
+    /*
+    std::string first, second;
+    first = ":" + iter.Value()->GetName();
+    first.append(generator.Generate());
+    second = ":" + GetDataStorage()->GetSources(iter->Value())->at(0)->GetData()->GetProperty("name")->GetValueAsString();
+    second.append(generator.Generate());
+
+    Node sub(Uri((std::string)first));
+    Node pred(Uri("dcterms:source"));
+    Node obj(Uri((std::string)second));
+
+    // TODO: Generate a UUID and add it to objects with UUID Generator of MITK in the following
+
+    Triple t(sub, pred, obj);
+    m_Store.Add(t);
+    std::cout << t;*/
+  }
 }
diff --git a/Plugins/org.mitk.gui.qt.rdftriplestore/src/internal/QmitkRdfTriplestoreView.h b/Plugins/org.mitk.gui.qt.rdftriplestore/src/internal/QmitkRdfTriplestoreView.h
index bcd21307bd..1400c2892d 100644
--- a/Plugins/org.mitk.gui.qt.rdftriplestore/src/internal/QmitkRdfTriplestoreView.h
+++ b/Plugins/org.mitk.gui.qt.rdftriplestore/src/internal/QmitkRdfTriplestoreView.h
@@ -1,63 +1,68 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #ifndef QmitkRdfTriplestoreView_h
 #define QmitkRdfTriplestoreView_h
 
 #include <berryISelectionListener.h>
 
 #include <QmitkAbstractView.h>
 
 #include "ui_QmitkRdfTriplestoreViewControls.h"
 
+#include "mitkRdfStore.h"
+
 /*!
 \brief QmitkRdfTriplestoreView
 
 \warning  This class is not yet documented. Use "git blame" and ask the author to provide basic documentation.
 
 \sa QmitkFunctionality
 \ingroup ${plugin_target}_internal
 */
 class QmitkRdfTriplestoreView : public QmitkAbstractView
 {
   // this is needed for all Qt objects that should have a Qt meta-object
   // (everything that derives from QObject and wants to have signal/slots)
   Q_OBJECT
 
 public:
 
   static const std::string VIEW_ID;
 
   virtual void CreateQtPartControl(QWidget *parent);
 
   protected slots:
 
     /// \brief Called when the user clicks the GUI button
     void GenerateRdfFile();
     void ImportRdfFile();
+    void DataStorageToTriples();
 
 protected:
 
   virtual void SetFocus();
 
   /// \brief called by QmitkFunctionality when DataManager's selection has changed
   virtual void OnSelectionChanged( berry::IWorkbenchPart::Pointer source,
     const QList<mitk::DataNode::Pointer>& nodes );
 
   Ui::QmitkRdfTriplestoreViewControls m_Controls;
+
+  mitk::RdfStore m_Store;
 };
 
 #endif // QmitkRdfTriplestoreView_h
diff --git a/Plugins/org.mitk.gui.qt.rdftriplestore/src/internal/QmitkRdfTriplestoreViewControls.ui b/Plugins/org.mitk.gui.qt.rdftriplestore/src/internal/QmitkRdfTriplestoreViewControls.ui
index 7819a72a65..091620cd44 100644
--- a/Plugins/org.mitk.gui.qt.rdftriplestore/src/internal/QmitkRdfTriplestoreViewControls.ui
+++ b/Plugins/org.mitk.gui.qt.rdftriplestore/src/internal/QmitkRdfTriplestoreViewControls.ui
@@ -1,134 +1,141 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>QmitkRdfTriplestoreViewControls</class>
  <widget class="QWidget" name="QmitkRdfTriplestoreViewControls">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>374</width>
     <height>322</height>
    </rect>
   </property>
   <property name="minimumSize">
    <size>
     <width>0</width>
     <height>0</height>
    </size>
   </property>
   <property name="windowTitle">
    <string>QmitkTemplate</string>
   </property>
   <layout class="QVBoxLayout" name="verticalLayout">
    <item>
     <widget class="QPushButton" name="buttonPerformGenerate">
      <property name="toolTip">
       <string>Do image processing</string>
      </property>
      <property name="text">
-      <string>Generate Rdf File</string>
+      <string>Generate Test Rdf File</string>
      </property>
     </widget>
    </item>
    <item>
     <widget class="QPushButton" name="buttonPerformImport">
      <property name="text">
-      <string>Import Generated Rdf File</string>
+      <string>Import Generated Test Rdf File</string>
+     </property>
+    </widget>
+   </item>
+   <item>
+    <widget class="QPushButton" name="buttonDataStorageToTriples">
+     <property name="text">
+      <string>DataStorage To Triplestore</string>
      </property>
     </widget>
    </item>
    <item>
     <widget class="QWidget" name="widgetAddTriple" native="true">
      <property name="enabled">
       <bool>false</bool>
      </property>
      <layout class="QGridLayout" name="gridLayout_2">
       <item row="3" column="0" colspan="3">
        <widget class="QPushButton" name="buttonNewTriple">
         <property name="text">
          <string>New Triple</string>
         </property>
        </widget>
       </item>
       <item row="2" column="0">
        <widget class="QLineEdit" name="lineEditDataNode">
         <property name="readOnly">
          <bool>true</bool>
         </property>
        </widget>
       </item>
       <item row="1" column="1">
        <widget class="QLabel" name="label_2">
         <property name="text">
          <string>Property</string>
         </property>
        </widget>
       </item>
       <item row="2" column="2">
        <widget class="QLineEdit" name="lineEditValue"/>
       </item>
       <item row="1" column="2">
        <widget class="QLabel" name="label_3">
         <property name="text">
          <string>Value</string>
         </property>
        </widget>
       </item>
       <item row="0" column="0" colspan="3">
        <widget class="QLabel" name="labelWarning">
         <property name="styleSheet">
          <string notr="true">QLabel { color: rgb(255, 0, 0) }</string>
         </property>
         <property name="text">
          <string>Please select a DataNode.</string>
         </property>
        </widget>
       </item>
       <item row="1" column="0">
        <widget class="QLabel" name="label">
         <property name="text">
          <string>DataNode</string>
         </property>
        </widget>
       </item>
       <item row="2" column="1">
        <widget class="QComboBox" name="comboBoxProperty">
         <property name="sizePolicy">
          <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
           <horstretch>0</horstretch>
           <verstretch>0</verstretch>
          </sizepolicy>
         </property>
         <property name="minimumSize">
          <size>
           <width>136</width>
           <height>0</height>
          </size>
         </property>
        </widget>
       </item>
      </layout>
     </widget>
    </item>
    <item>
     <spacer name="spacer1">
      <property name="orientation">
       <enum>Qt::Vertical</enum>
      </property>
      <property name="sizeType">
       <enum>QSizePolicy::Expanding</enum>
      </property>
      <property name="sizeHint" stdset="0">
       <size>
        <width>20</width>
        <height>220</height>
       </size>
      </property>
     </spacer>
    </item>
   </layout>
  </widget>
  <layoutdefault spacing="6" margin="11"/>
  <resources/>
  <connections/>
 </ui>