diff --git a/Modules/RDF/Testing/mitkRdfNodeTest.cpp b/Modules/RDF/Testing/mitkRdfNodeTest.cpp index 466b368e3d..5248d2f95d 100644 --- a/Modules/RDF/Testing/mitkRdfNodeTest.cpp +++ b/Modules/RDF/Testing/mitkRdfNodeTest.cpp @@ -1,51 +1,110 @@ /*=================================================================== 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 "mitkTestingMacros.h" #include #include #include "mitkRdfNode.h" class mitkRdfNodeTestSuite : public mitk::TestFixture { - // List of Tests CPPUNIT_TEST_SUITE(mitkRdfNodeTestSuite); - MITK_TEST(TestDummy); + // List of Tests + MITK_TEST(TestInvalidNode); + MITK_TEST(TestUriNode); + MITK_TEST(TestLiteralNode); + MITK_TEST(TestLiteralNodeWithDataType); + MITK_TEST(TestValueOfNode); + MITK_TEST(TestTypeOfNode); + MITK_TEST(TestDatatypeOfNode); CPPUNIT_TEST_SUITE_END(); +private: + + mitk::RdfNode emptyNode; + mitk::RdfUri base; + public: void setUp() { + emptyNode = mitk::RdfNode(); + base = mitk::RdfUri("http://mitk.org/wiki/MITK/data/BaseOntology.rdf#"); } void tearDown() { } // Test functions - void TestDummy() + void TestInvalidNode() + { + mitk::RdfNode anotherInvalidNode("", mitk::RdfUri()); + anotherInvalidNode.SetType(mitk::RdfNode::NOTHING); + CPPUNIT_ASSERT(emptyNode == anotherInvalidNode); + } + + void TestUriNode() + { + mitk::RdfNode uriNode = mitk::RdfNode(base); + emptyNode.SetValue(base.ToString()); + emptyNode.SetType(mitk::RdfNode::URI); + emptyNode.SetDatatype(mitk::RdfUri()); + CPPUNIT_ASSERT(uriNode == emptyNode); + } + + void TestLiteralNode() + { + mitk::RdfNode literalNode = mitk::RdfNode("Example"); + emptyNode.SetValue("Example"); + emptyNode.SetType(mitk::RdfNode::LITERAL); + emptyNode.SetDatatype(mitk::RdfUri()); + CPPUNIT_ASSERT(literalNode == emptyNode); + } + + void TestLiteralNodeWithDataType() + { + mitk::RdfNode literalNode = mitk::RdfNode("MyTest", mitk::RdfUri("xsd:string")); + emptyNode.SetValue("MyTest"); + emptyNode.SetType(mitk::RdfNode::LITERAL); + emptyNode.SetDatatype(mitk::RdfUri("xsd:string")); + CPPUNIT_ASSERT(literalNode == emptyNode); + } + + void TestValueOfNode() + { + mitk::RdfNode node(base); + CPPUNIT_ASSERT(base.ToString().compare(node.GetValue()) == 0); + } + + void TestTypeOfNode() + { + mitk::RdfNode node(base); + CPPUNIT_ASSERT(node.GetType() == mitk::RdfNode::URI); + } + + void TestDatatypeOfNode() { - mitk::RdfNode node; - CPPUNIT_ASSERT(true == true); + mitk::RdfNode literalNodeAgain = mitk::RdfNode("42", mitk::RdfUri("xsd:integer")); + CPPUNIT_ASSERT(literalNodeAgain.GetDatatype() == mitk::RdfUri("xsd:integer")); } }; MITK_TEST_SUITE_REGISTRATION(mitkRdfNode) diff --git a/Modules/RDF/Testing/mitkRdfStoreTest.cpp b/Modules/RDF/Testing/mitkRdfStoreTest.cpp index 0a83e80b3d..8d79d5ccdd 100644 --- a/Modules/RDF/Testing/mitkRdfStoreTest.cpp +++ b/Modules/RDF/Testing/mitkRdfStoreTest.cpp @@ -1,51 +1,123 @@ /*=================================================================== 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 "mitkTestingMacros.h" #include #include #include "mitkRdfStore.h" +#include + +#include class mitkRdfStoreTestSuite : public mitk::TestFixture { - // List of Tests CPPUNIT_TEST_SUITE(mitkRdfStoreTestSuite); - MITK_TEST(TestDummy); + // List of Tests + MITK_TEST(TestAddPrefix); + MITK_TEST(TestAddTriple); + MITK_TEST(TestRemoveTriple); + MITK_TEST(TestQueryTriple); + MITK_TEST(TestSaveStore); + MITK_TEST(TestImportStore); CPPUNIT_TEST_SUITE_END(); +private: + + mitk::RdfStore store; + mitk::RdfTriple triple; + public: void setUp() { + store.CleanUp(); + store.SetBaseUri(mitk::RdfUri("http://mitk.org/wiki/MITK/data/instances.rdf#")); + store.AddPrefix("dcterms", mitk::RdfUri("http://purl.org/dc/terms/")); + store.AddPrefix("mitk", mitk::RdfUri("http://mitk.org/wiki/MITK/data/BaseOntology.rdf#")); + triple = mitk::RdfTriple(mitk::RdfNode(mitk::RdfUri("http://mitk.org/wiki/MITK/data/instances.rdf#i0012")), + mitk::RdfNode(mitk::RdfUri("dcterms:title")), mitk::RdfNode("TestImage")); } void tearDown() { } // Test functions - void TestDummy() + void TestAddPrefix() { - CPPUNIT_ASSERT(true == true); + mitk::RdfUri fma = mitk::RdfUri("http://www.bioontology.org/projects/ontologies/fma/"); + store.AddPrefix("fma", fma); + std::map testMap = store.GetPrefixes(); + CPPUNIT_ASSERT(testMap.find("fma") != testMap.end()); } + void TestAddTriple() + { + store.Add(triple); + CPPUNIT_ASSERT(store.Contains(triple)); + } + + void TestRemoveTriple() + { + store.Add(triple); + store.Remove(triple); + CPPUNIT_ASSERT(!store.Contains(triple)); + } + + void TestQueryTriple() + { + store.Add(triple); + std::string query = "SELECT ?x WHERE { ?x ?z ?y . }"; + mitk::RdfStore::ResultMap queryResult = store.Query(query); + std::list list = queryResult["x"]; + CPPUNIT_ASSERT(triple.GetTripleSubject() == list.back()); + } + + void TestSaveStore() + { + store.Add(triple); + + std::ofstream tmpStream; + const std::string tmpFileName = mitk::IOUtil::CreateTemporaryFile(tmpStream); + store.Save(tmpFileName); + std::ifstream in(tmpFileName); + std::string s((std::istreambuf_iterator(in)), std::istreambuf_iterator()); + in.close(); + MITK_INFO << s; + tmpStream.close(); + + std::size_t found = s.find(":i0012"); + CPPUNIT_ASSERT(found!=std::string::npos); + } + + void TestImportStore() + { + std::ofstream tmpStream; + const std::string tmpFileName = mitk::IOUtil::CreateTemporaryFile(tmpStream); + const std::string strRDF = "@base . @prefix rdf: . @prefix : <> . @prefix dcterms: . @prefix mitk: . @prefix owl: . @prefix rdfs: . @prefix xsd: . :i0012 'TestImage' ."; + tmpStream << strRDF; + tmpStream.close(); + + store.Import("file:"+tmpFileName); + CPPUNIT_ASSERT(store.Contains(triple)); + } }; MITK_TEST_SUITE_REGISTRATION(mitkRdfStore) diff --git a/Modules/RDF/Testing/mitkRdfTripleTest.cpp b/Modules/RDF/Testing/mitkRdfTripleTest.cpp index 54e2d6ddf4..75f70deca2 100644 --- a/Modules/RDF/Testing/mitkRdfTripleTest.cpp +++ b/Modules/RDF/Testing/mitkRdfTripleTest.cpp @@ -1,51 +1,120 @@ /*=================================================================== 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 "mitkTestingMacros.h" #include #include #include "mitkRdfTriple.h" class mitkRdfTripleTestSuite : public mitk::TestFixture { - // List of Tests CPPUNIT_TEST_SUITE(mitkRdfTripleTestSuite); - MITK_TEST(TestDummy); + // List of Tests + MITK_TEST(TestEmptyTriple); + MITK_TEST(TestObjectTriple); + MITK_TEST(TestDataTriple); + MITK_TEST(TestSubjectOfTriple); + MITK_TEST(TestPredicateOfTriple); + MITK_TEST(TestObjectOfTripleAsObject); + MITK_TEST(TestObjectOfTripleAsData); CPPUNIT_TEST_SUITE_END(); +private: + + mitk::RdfTriple emptyTriple; + mitk::RdfUri seg; + mitk::RdfUri title; + public: void setUp() { + emptyTriple = mitk::RdfTriple(); + title = mitk::RdfUri("dcterms:title"); + seg = mitk::RdfUri("http://mitk.org/wiki/MITK/data/instance.rdf#s0001"); } void tearDown() { } // Test functions - void TestDummy() + void TestEmptyTriple() + { + mitk::RdfTriple anotherTriple = mitk::RdfTriple( + mitk::RdfNode(), mitk::RdfNode(), mitk::RdfNode()); + CPPUNIT_ASSERT(emptyTriple == anotherTriple); + } + + void TestObjectTriple() + { + mitk::RdfUri src = mitk::RdfUri("dcterms:source"); + mitk::RdfUri image = mitk::RdfUri("http://mitk.org/wiki/MITK/data/instance.rdf#i0012"); + mitk::RdfTriple objectTriple = mitk::RdfTriple( + mitk::RdfNode(seg), mitk::RdfNode(src), mitk::RdfNode(image)); + emptyTriple.SetTripleSubject(seg); + emptyTriple.SetTriplePredicate(src); + emptyTriple.SetTripleObject(mitk::RdfNode(image)); + CPPUNIT_ASSERT(emptyTriple == objectTriple); + } + + void TestDataTriple() + { + mitk::RdfTriple dataTriple = mitk::RdfTriple( + mitk::RdfNode(seg), mitk::RdfNode(title), "TestLiver"); + emptyTriple.SetTripleSubject(seg); + emptyTriple.SetTriplePredicate(title); + emptyTriple.SetTripleObject("TestLiver"); + CPPUNIT_ASSERT(emptyTriple == dataTriple); + } + + void TestSubjectOfTriple() + { + mitk::RdfTriple triple = mitk::RdfTriple( + mitk::RdfNode(seg), mitk::RdfNode(title), "KidneyLeft"); + + CPPUNIT_ASSERT(triple.GetTripleSubject() == mitk::RdfNode(seg)); + } + + void TestPredicateOfTriple() { - CPPUNIT_ASSERT(true == true); + mitk::RdfTriple triple = mitk::RdfTriple( + mitk::RdfNode(seg), mitk::RdfNode(title), "KidneyRight"); + CPPUNIT_ASSERT(triple.GetTriplePredicate() == mitk::RdfNode(title)); } + void TestObjectOfTripleAsObject() + { + mitk::RdfNode image = mitk::RdfNode( + mitk::RdfUri("http://mitk.org/wiki/MITK/data/instance.rdf#i0012")); + mitk::RdfTriple triple = mitk::RdfTriple( + mitk::RdfNode(seg), mitk::RdfNode(mitk::RdfUri("dcterms:source")), image); + CPPUNIT_ASSERT(triple.GetTripleObject() == image); + } + + void TestObjectOfTripleAsData() + { + mitk::RdfTriple triple = mitk::RdfTriple( + mitk::RdfNode(seg), mitk::RdfNode(mitk::RdfUri("mitk:volumeInMl")), "450"); + CPPUNIT_ASSERT(triple.GetTripleObject() == mitk::RdfNode("450")); + } }; MITK_TEST_SUITE_REGISTRATION(mitkRdfTriple) diff --git a/Modules/RDF/Testing/mitkRdfUriTest.cpp b/Modules/RDF/Testing/mitkRdfUriTest.cpp index 261246fbc0..206dbaee51 100644 --- a/Modules/RDF/Testing/mitkRdfUriTest.cpp +++ b/Modules/RDF/Testing/mitkRdfUriTest.cpp @@ -1,51 +1,74 @@ /*=================================================================== 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 "mitkTestingMacros.h" #include #include #include "mitkRdfUri.h" class mitkRdfUriTestSuite : public mitk::TestFixture { - // List of Tests CPPUNIT_TEST_SUITE(mitkRdfUriTestSuite); - MITK_TEST(TestDummy); + // List of Tests + MITK_TEST(TestEmptyUri); + MITK_TEST(TestValueOfUri); + MITK_TEST(TestSetUri); CPPUNIT_TEST_SUITE_END(); +private: + + mitk::RdfUri m_EmptyUri; + std::string m_UriText; + mitk::RdfUri m_Uri; + public: void setUp() { + // normal URI + m_UriText = "http://mitk.org/wiki/MITK/data/BaseOntology.rdf#"; + m_Uri = mitk::RdfUri(m_UriText); } void tearDown() { } // Test functions - void TestDummy() + void TestEmptyUri() { - CPPUNIT_ASSERT(true == true); + mitk::RdfUri anotherEmptyUri(""); + CPPUNIT_ASSERT(m_EmptyUri == anotherEmptyUri); } + void TestValueOfUri() + { + CPPUNIT_ASSERT(m_Uri.ToString().compare(m_UriText) == 0); + } + + void TestSetUri() + { + mitk::RdfUri newUri; + newUri.SetUri(m_UriText); + CPPUNIT_ASSERT(newUri == m_Uri); + } }; MITK_TEST_SUITE_REGISTRATION(mitkRdfUri) diff --git a/Modules/RDF/mitkRdfNode.cpp b/Modules/RDF/mitkRdfNode.cpp index e39aa938c4..f5ca0bc4d4 100644 --- a/Modules/RDF/mitkRdfNode.cpp +++ b/Modules/RDF/mitkRdfNode.cpp @@ -1,104 +1,117 @@ /*=================================================================== 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 "mitkRdfNode.h" #include #include #include #include namespace mitk { RdfNode::RdfNode() : m_Type(NOTHING) { } RdfNode::RdfNode(RdfUri uri) : m_Type(URI), m_Value(uri.ToString()) { } RdfNode::RdfNode(std::string text) : m_Type(LITERAL), m_Value(text) { } RdfNode::RdfNode(std::string text, RdfUri dataType) : m_Type(LITERAL), m_Value(text), m_Datatype(dataType) { } RdfNode::~RdfNode() { } void RdfNode::SetType(RdfNode::Type type) { m_Type = type; } void RdfNode::SetDatatype(RdfUri dataType) { m_Datatype = dataType; } void RdfNode::SetValue(std::string value) { m_Value = value; } RdfNode::Type RdfNode::GetType() const { return m_Type; } RdfUri RdfNode::GetDatatype() const { return m_Datatype; } std::string RdfNode::GetValue() const { return m_Value; } + bool RdfNode::operator==(const RdfNode &u) const + { + if (this->m_Type != u.m_Type) return false; + if (this->m_Value.compare(u.m_Value) != 0) return false; + if (this->m_Datatype != u.m_Datatype) return false; + return true; + } + + bool RdfNode::operator!=(const RdfNode &u) const + { + return !operator==(u); + } + // Define outstream of a Node std::ostream & operator<<(std::ostream &out, const RdfNode &n) { switch (n.GetType()) { case RdfNode::NOTHING: out << "[]"; break; case RdfNode::URI: if (n.GetValue() == "") { out << "[empty-uri]"; } else { out << "<" << n.GetValue() << ">"; } break; case RdfNode::LITERAL: out << "\"" << n.GetValue() << "\""; if (n.GetDatatype() != RdfUri()) out << "^^" << n.GetDatatype(); break; case RdfNode::BLANK: out << "[blank " << n.GetValue() << "]"; break; } return out; } } diff --git a/Modules/RDF/mitkRdfNode.h b/Modules/RDF/mitkRdfNode.h index 93a21921ef..ca18b0d43f 100644 --- a/Modules/RDF/mitkRdfNode.h +++ b/Modules/RDF/mitkRdfNode.h @@ -1,111 +1,114 @@ /*=================================================================== 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 MITKRDFNODE_H #define MITKRDFNODE_H #include #include "mitkRdfUri.h" #include #include namespace mitk { /** * \ingroup MitkRDFModule */ class MitkRDF_EXPORT RdfNode { public: /** * Enumeration for node types. */ enum Type { NOTHING, URI, LITERAL, BLANK }; /** * Construct a empty invalid node. */ RdfNode(); /** * Construct a node from type URI which represents a object of the real world. * @param uri An RdfUri which represents a URI. */ RdfNode(RdfUri uri); /** * Construct a node from type LITERAL. * @param text A std::string which represents a literal. */ RdfNode(std::string text); /** * Construct a node from type LITERAL with a specific data type. * @param text A std::string which represents a literal. * @param dataType An RdfUri which represents a specific data type. */ RdfNode(std::string text, RdfUri dataType); virtual ~RdfNode(); /** * Set the type of a Node. * @param type An RdfNode::Type which represents a type of a node. */ void SetType(Type type); /** * Set the data type of a LITERAL Node. * @param dataType An RdfUri which represents an URI of a specific data type. */ void SetDatatype(RdfUri dataType); /** * Set the internal represantation of an URI or a text. * @param value A std::string which represents an URI or a text. */ void SetValue(std::string value); /** * Get the type of a node. * @return The type of a node. */ Type GetType() const; /** * Get the data type of the internal value of a node. * @return The data type of the internal value of a node. */ RdfUri GetDatatype() const; /** * Get the internal value of a node. * @return The internal value of a node. */ std::string GetValue() const; + bool operator==(const RdfNode &u) const; + bool operator!=(const RdfNode &u) const; + private: Type m_Type; RdfUri m_Datatype; std::string m_Value; }; MitkRDF_EXPORT std::ostream & operator<<(std::ostream &out, const mitk::RdfNode &n); } #endif diff --git a/Modules/RDF/mitkRdfStore.cpp b/Modules/RDF/mitkRdfStore.cpp index 6a11d05a61..dff8e68dde 100644 --- a/Modules/RDF/mitkRdfStore.cpp +++ b/Modules/RDF/mitkRdfStore.cpp @@ -1,418 +1,423 @@ /*=================================================================== 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 #include 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[""] = RdfUri(m_BaseUri.ToString()+"#"); + m_Prefixes[""] = RdfUri(m_BaseUri.ToString()); } RdfUri RdfStore::GetBaseUri() { return m_BaseUri; } void RdfStore::AddPrefix(std::string prefix, RdfUri uri) { m_Prefixes[prefix] = uri; } + RdfStore::PrefixMap RdfStore::GetPrefixes() + { + return m_Prefixes; + } + 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); if(!m_Storage) { mitkThrow() << "RDF Library Error"; } m_Model = librdf_new_model(m_World, m_Storage, 0); if(!m_Model) { mitkThrow() << "RDF Library Error"; } } bool RdfStore::Add(RdfTriple triple) { librdf_statement* statement = RdfTripleToStatement(triple); if (!CheckComplete(statement)) { librdf_free_statement(statement); return false; } // Store already contains statement if (Contains(triple)) return true; if (librdf_model_add_statement(m_Model, statement) != 0) { librdf_free_statement(statement); return false; } else { librdf_free_statement(statement); return true; } } bool RdfStore::Remove(RdfTriple triple) { librdf_statement* statement = RdfTripleToStatement(triple); if (!CheckComplete(statement)) { librdf_free_statement(statement); return false; } // Store does not contain statement if (!Contains(triple)) return true; if (librdf_model_remove_statement(m_Model, statement) != 0) { librdf_free_statement(statement); return false; } else { librdf_free_statement(statement); return true; } return false; } bool RdfStore::Contains(RdfTriple triple) { 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; } 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_query* rdfQuery = librdf_new_query(m_World, "sparql", 0, (const unsigned char*) completeQuery.c_str(), 0); if (!rdfQuery) return resultMap; librdf_query_results* results = librdf_query_execute(rdfQuery, m_Model); if (!results) { librdf_free_query(rdfQuery); return resultMap; } if (!librdf_query_results_is_bindings(results)) { librdf_free_query_results(results); librdf_free_query(rdfQuery); return resultMap; } while (!librdf_query_results_finished(results)) { int count = librdf_query_results_get_bindings_count(results); for (int i = 0; i < count; ++i) { const char *name = librdf_query_results_get_binding_name(results, i); if (!name) continue; std::string key = name; std::list list; if(!resultMap[key].empty()) { list = resultMap[key]; } librdf_node *node = librdf_query_results_get_binding_value(results, i); list.push_front(LibRdfNodeToRdfNode(node)); resultMap[key] = list; } librdf_query_results_next(results); } librdf_free_query_results(results); librdf_free_query(rdfQuery); return resultMap; } void RdfStore::Save(std::string filename, std::string format) { if (format == "") format = "turtle"; librdf_uri* baseUri = RdfUriToLibRdfUri(m_BaseUri); librdf_serializer* s = librdf_new_serializer(m_World, format.c_str(), 0, 0); if(!s) { mitkThrow() << "RDF Library Error"; } 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()); } FILE* f = fopen(filename.c_str(), "w+"); librdf_serializer_serialize_model_to_file_handle(s, f, baseUri, m_Model); librdf_free_serializer(s); librdf_free_uri(baseUri); fclose(f); } void RdfStore::Import(std::string url, std::string format) { std::string baseUri = m_BaseUri.ToString(); if (baseUri.empty()) { baseUri = url; SetBaseUri(RdfUri(baseUri)); } if (format == "") format= "turtle"; // Redland uses file paths like file:YOURPATH ( Example: 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(!p) { mitkThrow() << "RDF Library Error"; } if (librdf_parser_parse_into_model(p, uri, libRdfBaseUri, m_Model) != 0 ) { librdf_free_parser(p); MITK_ERROR << "Parsing into Model 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); } } librdf_free_parser(p); } /***************************************************************************** ********************************** 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.GetTripleSubject()); librdf_node* predicate = RdfNodeToLibRdfNode(triple.GetTriplePredicate()); librdf_node* object = RdfNodeToLibRdfNode(triple.GetTripleObject()); 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.GetType()) { case RdfNode::NOTHING: break; case RdfNode::BLANK: newNode = librdf_new_node_from_blank_identifier(m_World, (const unsigned char*) node.GetValue().c_str()); break; case RdfNode::LITERAL: { if (node.GetDatatype() != RdfUri()) { librdf_uri* typeUri = RdfUriToLibRdfUri(node.GetDatatype()); newNode = librdf_new_node_from_typed_literal(m_World, (const unsigned char*) node.GetValue().c_str(), 0, typeUri); } else { newNode = librdf_new_node_from_literal(m_World, (const unsigned char*) node.GetValue().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.GetValue().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; } 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); RdfTriple triple(LibRdfNodeToRdfNode(subject), LibRdfNodeToRdfNode(predicate), LibRdfNodeToRdfNode(object)); return triple; } RdfNode RdfStore::LibRdfNodeToRdfNode(librdf_node* node) { RdfNode mitkNode; if (!node) return 0; if (librdf_node_is_resource(node)) { mitkNode.SetType(RdfNode::URI); librdf_uri *uri = librdf_node_get_uri(node); mitkNode.SetValue(LibRdfUriToRdfUri(uri).ToString()); } else if (librdf_node_is_literal(node)) { mitkNode.SetType(RdfNode::LITERAL); std::string value = (const char*) librdf_node_get_literal_value(node); if (!value.empty()) mitkNode.SetValue(value); librdf_uri* typeUri = librdf_node_get_literal_value_datatype_uri(node); if (typeUri) mitkNode.SetDatatype(LibRdfUriToRdfUri(typeUri)); } else if (librdf_node_is_blank(node)) { mitkNode.SetType(RdfNode::BLANK); std::string str = (const char*) librdf_node_get_blank_identifier(node); if (!str.empty()) mitkNode.SetValue(str); } return mitkNode; } 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 94a1d08f5b..4eb5575214 100644 --- a/Modules/RDF/mitkRdfStore.h +++ b/Modules/RDF/mitkRdfStore.h @@ -1,134 +1,140 @@ /*=================================================================== 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 #include #include #include #include "mitkRdfTriple.h" namespace mitk { /** * \ingroup MitkRDFModule */ class MitkRDF_EXPORT RdfStore { public: typedef std::map > ResultMap; typedef std::map PrefixMap; /** * Construct a new triplestore. */ RdfStore(); ~RdfStore(); /** * Set the base URI of the triplestore. * @param uri An URI which is the base for the triplestore and for new nodes. */ void SetBaseUri(RdfUri uri); /** * Get the base URI of the triplestore. */ RdfUri GetBaseUri(); /** * Add a new prefix which represents an URI as an abbreviation to the triplestore. * @param prefix The short form of an URI. * @param uri The full form of an URI. */ void AddPrefix(std::string prefix, RdfUri uri); + /** + * Get a Map with all prefixes of the triplestore. + * @return A Map with all Prefixes of the RdfStore. + */ + PrefixMap GetPrefixes(); + /** * Clean up the triplestore to the state of a new store. */ void CleanUp(); /** * Add a new triple to the triplestore. * Checks if the triplestore contains the triple. * @param triple A triple. * @return If the triple is successfully added or if the triplestore already contains the triple, true will be returned. If none of the previous options happen, false will be returned. */ bool Add(RdfTriple triple); /** * Remove a triple from the triplestore. * Checks if the triplestore contains the triple. * @param triple A triple. * @return If the triple is successfully removed or if the triplestore doesn't contain the triple, true will be returned. If none of the previous options happen, false will be returned. */ bool Remove(RdfTriple triple); /** * Checks if the triplestore contains the triple. * @param triple A triple. * @return If the triplestore contains the triple, true will be returned. Otherwise, false will be returned. */ bool Contains(RdfTriple triple); /** * Queries over the triplestore with the given SPARQL query. * @param query A std:string which stands for a SPARQL query text. * @return The result of the query will be returned as a map of keys with there values as lists of nodes. */ ResultMap Query(std::string query); /** * Saves the current state of the triplestore in a file. The currently supported formats are: "ntriples", "turtle"(default), "nquads". * @param filename A full filepath to the lokal storage. * @param format One of the supported formats. Default: "turtle". */ void Save(std::string filename, std::string format = ""); /** * Imports the state of the triplestore of an URL (URI). * @param filename A full filepath to the lokal storage or http address as URL. A lokal file path has to look like "file:YOURPATH" ( Example: file:D:/home/readme.txt ). * @param format The current supported formats are: "turtle" (default), "ntriples", "nquads". */ void Import(std::string url, std::string format = ""); private: RdfUri m_BaseUri; 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/mitkRdfTriple.cpp b/Modules/RDF/mitkRdfTriple.cpp index 4396f45963..23ef8fcdbe 100644 --- a/Modules/RDF/mitkRdfTriple.cpp +++ b/Modules/RDF/mitkRdfTriple.cpp @@ -1,73 +1,92 @@ /*=================================================================== 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 "mitkRdfTriple.h" namespace mitk { RdfTriple::RdfTriple() { } RdfTriple::RdfTriple(RdfNode subject, RdfNode predicate, RdfNode object) : m_Subject(subject), m_Predicate(predicate), m_Object(object) { } RdfTriple::RdfTriple(RdfNode subject, RdfNode property, std::string value) : m_Subject(subject), m_Predicate(property), m_Object(RdfNode(value)) { } RdfTriple::~RdfTriple() { } void RdfTriple::SetTripleSubject(RdfNode subject) { m_Subject = subject; } void RdfTriple::SetTriplePredicate(RdfNode predicate) { m_Predicate = predicate; } void RdfTriple::SetTripleObject(RdfNode object) { m_Object = object; } + void RdfTriple::SetTripleObject(std::string text) + { + mitk::RdfNode object = mitk::RdfNode(text); + m_Object = object; + } + RdfNode RdfTriple::GetTripleSubject() const { return m_Subject; } RdfNode RdfTriple::GetTriplePredicate() const { return m_Predicate; } RdfNode RdfTriple::GetTripleObject() const { return m_Object; } + bool RdfTriple::operator==(const RdfTriple &u) const + { + if (this->m_Subject != u.m_Subject) return false; + if (this->m_Predicate != m_Predicate) return false; + if (this->m_Object != u.m_Object) return false; + return true; + } + + bool RdfTriple::operator!=(const RdfTriple &u) const + { + return !operator==(u); + } + // Define outstream of a Triple std::ostream & operator<<(std::ostream &out, const RdfTriple &t) { return out << "( " << t.GetTripleSubject() << " " << t.GetTriplePredicate() << " " << t.GetTripleObject() << " )"; } } // end of namespace mitk diff --git a/Modules/RDF/mitkRdfTriple.h b/Modules/RDF/mitkRdfTriple.h index db7dc8e8f8..724db581ca 100644 --- a/Modules/RDF/mitkRdfTriple.h +++ b/Modules/RDF/mitkRdfTriple.h @@ -1,100 +1,109 @@ /*=================================================================== 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 MITKRDFTRIPLE_H #define MITKRDFTRIPLE_H #include #include "mitkRdfNode.h" namespace mitk { /** * \ingroup MitkRDFModule */ class MitkRDF_EXPORT RdfTriple { public: /** * Construct a empty invalid triple. */ RdfTriple(); /** * Construct a normal triple with two nodes and an object property node between. * @param subject A node. * @param predicate A node which represents an object property. * @param object A node. */ RdfTriple(RdfNode subject, RdfNode predicate, RdfNode object); /** * Construct a normal triple with a node, a data property and a value. * @param subject A node. * @param predicate A node which represents a data property. * @param value A text value. */ RdfTriple(RdfNode subject, RdfNode property, std::string value); virtual ~RdfTriple(); /** * Set the subject of a triple. * @param subject A node from type URI or BLANK. */ void SetTripleSubject(RdfNode subject); /** * Set the predicate of a triple. * @param predicate A node from type URI which can represent an object property or a data property. */ void SetTriplePredicate(RdfNode predicate); /** - * Set the object of a triple. + * Set the object of a triple with an object property. * @param object A node from type URI, BLANK or LITERAL. */ void SetTripleObject(RdfNode object); + /** + * Set the object of a triple with a data property as text. + * @param text A literal value.. + */ + void SetTripleObject(std::string text); + /** * Get the subject of a triple. * @return The subject of a triple. */ RdfNode GetTripleSubject() const; /** * Get the predicate of a triple. * @return The predicate of a triple. */ RdfNode GetTriplePredicate() const; /** * Get the object of a triple. * @return The object of a triple. */ RdfNode GetTripleObject() const; + bool operator==(const RdfTriple &u) const; + bool operator!=(const RdfTriple &u) const; + private: RdfNode m_Subject; RdfNode m_Predicate; RdfNode m_Object; }; MitkRDF_EXPORT std::ostream & operator<<(std::ostream &out, const RdfTriple &t); } #endif // MITKRDFTRIPLE_H diff --git a/Modules/RDF/mitkRdfUri.h b/Modules/RDF/mitkRdfUri.h index 56c7684803..8e003176f1 100644 --- a/Modules/RDF/mitkRdfUri.h +++ b/Modules/RDF/mitkRdfUri.h @@ -1,64 +1,64 @@ /*=================================================================== 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 #include namespace mitk { /** * \ingroup MitkRDFModule */ class MitkRDF_EXPORT RdfUri { public: /** * Construct a empty RdfUri. */ RdfUri(); /** * Construct a RdfUri with a value. - * @param uri A std:string represents the transfer parameter from a URI. + * @param uri A std:string which represents the transfer parameter from a URI. */ explicit RdfUri(std::string uri); virtual ~RdfUri(); /** * Returns the string value of an RdfUri. * @return Value of RdfUri as std:string. */ std::string ToString() const; /** * Set the value of an RdfUri. * @param uri New value of an RdfUri. */ void SetUri(std::string uri); 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 90e87a83e7..12bc1afcc8 100644 --- a/Plugins/org.mitk.gui.qt.rdftriplestore/src/internal/QmitkRdfTriplestoreView.cpp +++ b/Plugins/org.mitk.gui.qt.rdftriplestore/src/internal/QmitkRdfTriplestoreView.cpp @@ -1,363 +1,355 @@ /*=================================================================== 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 #include // Qmitk #include "QmitkRdfTriplestoreView.h" // Qt #include #include // Mitk #include #include #include #include #include #include #include // GDCM #include // STD #include 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 ); 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); m_Controls.comboBoxProperty->addItem("title"); m_Controls.comboBoxProperty->addItem("source"); m_Controls.comboBoxProperty->addItem("format"); // Set up the Triplestore m_Store.SetBaseUri(Uri("http://www.mitk.org/BaseOntology")); m_Store.Import("file:D:/home/knorr/builds/tripleStore/Ontologies/dcterms.ttl"); Uri bomrdf("file:C:/Users/knorr/Desktop/BaseOntologyMitk.rdf"); m_Store.AddPrefix("mitk", bomrdf); Uri dc("http://purl.org/dc/terms/"); m_Store.AddPrefix("dcterms", dc); 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& 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->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("mitk", Uri("file:C:/Users/knorr/Desktop/BaseOntologyMitk.rdf#")); store.AddPrefix("sfm", Uri("file:C:/Users/knorr/Desktop/storeFromMitk.rdf#")); store.AddPrefix("dcterms", Uri("http://purl.org/dc/terms/")); // Create some nodes mitk::RdfNode project1(mitk::RdfUri("sfm:Project1")); mitk::RdfNode subject1(mitk::RdfUri("sfm:Subject1")); mitk::RdfNode proj(mitk::RdfUri("mitk:Project")); mitk::RdfNode subj(mitk::RdfUri("mitk:Subject")); // Create some predicate(/property) nodes mitk::RdfNode hasA(mitk::RdfUri("mitk:has")); mitk::RdfNode name(mitk::RdfUri("mitk:name")); mitk::RdfNode a(mitk::RdfUri("rdf:type")); // Create some triples mitk::RdfTriple t1(project1, hasA, subject1); 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(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"); // Selects all triples in the storage std::string query = "PREFIX dcterms: SELECT ?x ?y ?z ?a WHERE {?x dcterms:source ?z ; dcterms:title ?y . ?z dcterms:title ?a . }"; Store::ResultMap map = m_Store.Query(query); //MITK_INFO << i->first << " " << i->second.value << " " << i->second.type << " " << i->second.datatype; std::list listX(map["x"]); std::list listY(map["y"]); std::list listZ(map["z"]); std::list listA(map["a"]); MITK_INFO << "| node1 " << "| name1 " << "| node2 " << "| name2 " << "|"; std::list::const_iterator x = listX.begin(); std::list::const_iterator y = listY.begin(); std::list::const_iterator z = listZ.begin(); std::list::const_iterator aa = listA.begin(); for (; x != listX.end(); x++,y++,z++,aa++) { MITK_INFO << "| " << x->GetValue() << " | " << y->GetValue() << " | " << z->GetValue() << " | " << aa->GetValue() << " |"; } /* for (int i = 1; i <= counter; i++) { MITK_INFO << "x" << " " << "y" << " " << "z"; MITK_INFO << listX.back().value << " " << listY.back().value << " " << listZ.back().value; listX.pop_back(); listY.pop_back(); listZ.pop_back(); } */ 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:D:/home/knorr/builds/tripleStore/Ontologies/dcterms.ttl"); store.Import("file:D:/home/knorr/builds/tripleStore/Ontologies/fma_3.1.ttl"); //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 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::Pointer isBaseData = // mitk::TNodePredicateDataType::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 nodeUUID = generator.Generate(); if(!node->GetProperty("uuid")){ node->SetProperty("uuid", mitk::StringProperty::New(nodeUUID)); } } 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(); std::string nodeUUID = node->GetProperty("uuid")->GetValueAsString(); std::string path; if(node->GetProperty("path")){ path = node->GetProperty("path")->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->GetValueAsString();//getvalueasstring() //} Uri firstT(":" + nodeUUID/* + name*/); //Uri secondT(name); Node subT(firstT); Node predT(Uri("http://purl.org/dc/terms/title")); Node objT(name); Triple tparent(subT, predT, objT); m_Store.Add(tparent); std::cout << tparent << std::endl; if(!path.empty()){ Uri firstP(":" + nodeUUID/* + name*/); //Uri secondP(path); Node subP(firstP); Node predP(Uri("mitk:filepath")); Node objP(path); Triple pathTriple(subP, predP, objP); m_Store.Add(pathTriple); std::cout << pathTriple << std::endl; } Node rdfType(Uri("rdf:type")); // Check if mitk::Image mitk::Image* image = dynamic_cast(node->GetData()); if(image) { bool isSeg = false; node->GetBoolProperty("binary", isSeg); if(isSeg) { Node seg(Uri("mitk:Segmentation")); Triple tType(subT, rdfType, seg); std::cout << tType << std::endl; } else { Node img(Uri("mitk:Image")); Triple tType(subT, rdfType, img); std::cout << tType << std::endl; } } // Check if Surface mitk::Surface* surface = dynamic_cast(node->GetData()); if(surface) { Node surf(Uri("mitk:Surface")); Triple tType(subT, rdfType, surf); std::cout << tType << std::endl; } // Check if PointSet mitk::PointSet* pointSet = dynamic_cast(node->GetData()); if(pointSet) { Node pSet(Uri("mitk:PointSet")); Triple tType(subT, rdfType, pSet); std::cout << tType << std::endl; } // Get the parent of a DataNode mitk::DataStorage::SetOfObjects::ConstPointer sourceContainer = GetDataStorage()->GetSources(node); for( mitk::DataStorage::SetOfObjects::ConstIterator sources = sourceContainer->Begin(); sources != sourceContainer->End(); sources++ ) { const mitk::DataNode::Pointer sourceNode = sources->Value(); std::string sourceName = sourceNode->GetProperty("name")->GetValueAsString(); std::string sourceUUID = sourceNode->GetProperty("uuid")->GetValueAsString(); //sourceNode->SetProperty("uuid", mitk::StringProperty::New(sourceUUID)); // ENUM mit dublincore properties oder string array - // TODO: Name(title) - //Uri firstT(":" + nodeUUID + name); - //Uri secondT(name); - //Node subT(firstT); - //Node predT(Uri("dcterms:title")); - //Node objT(secondT); - //Triple tName(subT, predT, objT); - // Parent(source) Uri first(":" + nodeUUID/* + name*/); Uri second(":" + sourceUUID/* + sourceName*/); Node sub(first); Node pred(Uri("http://purl.org/dc/terms/source")); Node obj(second); Triple t(sub, pred, obj); //m_Store.Add(tName); m_Store.Add(t); //std::cout << tName << std::endl; std::cout << t << std::endl; // TODO: Add all properties to store // TODO: Save store } } }