From 9ce65c5a963b03ee97fe9cb6c5aa65a3c04a80a8 Mon Sep 17 00:00:00 2001
From: yzhou <yujiao.zhou@gmail.com>
Date: Tue, 21 Apr 2015 10:34:27 +0100
Subject: initial version

---
 src/uk/ac/ox/cs/pagoda/summary/Graph.java | 154 ++++++++++++++++++++++++++++++
 1 file changed, 154 insertions(+)
 create mode 100644 src/uk/ac/ox/cs/pagoda/summary/Graph.java

(limited to 'src/uk/ac/ox/cs/pagoda/summary/Graph.java')

diff --git a/src/uk/ac/ox/cs/pagoda/summary/Graph.java b/src/uk/ac/ox/cs/pagoda/summary/Graph.java
new file mode 100644
index 0000000..cfa94a4
--- /dev/null
+++ b/src/uk/ac/ox/cs/pagoda/summary/Graph.java
@@ -0,0 +1,154 @@
+package uk.ac.ox.cs.pagoda.summary;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.Map;
+import java.util.Set;
+
+import org.semanticweb.HermiT.model.Constant;
+import org.semanticweb.HermiT.model.Individual;
+import org.semanticweb.HermiT.model.Term;
+import org.semanticweb.owlapi.model.OWLAxiom;
+import org.semanticweb.owlapi.model.OWLClass;
+import org.semanticweb.owlapi.model.OWLClassAssertionAxiom;
+import org.semanticweb.owlapi.model.OWLObjectProperty;
+import org.semanticweb.owlapi.model.OWLObjectPropertyAssertionAxiom;
+import org.semanticweb.owlapi.model.OWLOntology;
+
+import uk.ac.ox.cs.JRDFox.model.GroundTerm;
+import uk.ac.ox.cs.JRDFox.model.Literal;
+import uk.ac.ox.cs.pagoda.query.AnswerTuple;
+
+public class Graph {
+	
+	Set<Node> nodes = new HashSet<Node>(); 
+	Map<Node, Edge[]> sortedOutGoingEdges = new HashMap<Node, Edge[]>(); 
+	Map<Node, Edge[]> sortedInComingEdges = new HashMap<Node, Edge[]>(); 
+	
+	public Graph(OWLOntology ontology) {
+		Map<Node, Collection<Edge>> outGoingEdges = new HashMap<Node, Collection<Edge>>(); 
+		Map<Node, Collection<Edge>> inComingEdges = new HashMap<Node, Collection<Edge>>();
+		
+		for (OWLAxiom axiom: ontology.getABoxAxioms(true))
+			if (axiom instanceof OWLClassAssertionAxiom) 
+				addClassAssertion((OWLClassAssertionAxiom) axiom); 
+			else if (axiom instanceof OWLObjectPropertyAssertionAxiom)
+				addPropertyAssertion((OWLObjectPropertyAssertionAxiom) axiom, inComingEdges, outGoingEdges); 
+		
+		for (Node node: nodes) {
+			sortedOutGoingEdges.put(node, sort(outGoingEdges.get(node)));
+			sortedInComingEdges.put(node, sort(inComingEdges.get(node))); 
+		}
+		
+		outGoingEdges.clear();
+		inComingEdges.clear(); 
+	}
+	
+	public Collection<Node> getNodes() { return nodes; }
+
+	private void addPropertyAssertion(OWLObjectPropertyAssertionAxiom axiom, 
+			Map<Node, Collection<Edge>> inComingEdges, Map<Node, Collection<Edge>> outGoingEdges) {
+		
+		Node u = getNode(axiom.getSubject().toStringID()), v = getNode(axiom.getObject().toStringID());
+			
+		nodes.add(u); 
+		nodes.add(v); 
+		
+		Edge e = new Edge(u, v, ((OWLObjectProperty) axiom.getProperty()).toStringID());
+		
+		Collection<Edge> edges = outGoingEdges.get(u); 
+		if (edges == null) {
+			edges = new LinkedList<Edge>();
+			outGoingEdges.put(u, edges); 
+		}
+		edges.add(e);
+		
+		edges = inComingEdges.get(v); 
+		if (edges == null) {
+			edges = new LinkedList<Edge>(); 
+			inComingEdges.put(v, edges); 
+		}
+		edges.add(e); 
+	}
+
+	private void addClassAssertion(OWLClassAssertionAxiom axiom) {
+		OWLClass cls = (OWLClass) axiom.getClassExpression();
+		Node u; 
+//		if (cls.getIRI().toString().startsWith(HermitSummaryFilter.QueryAnswerTermPrefix))
+//			u = getNode(axiom.getIndividual().toStringID(), false);
+//		else 
+			u = getNode(axiom.getIndividual().toStringID());
+		
+		if (u == null) return ; 
+		u.addConcept(cls.toStringID());
+		nodes.add(u); 
+	}
+
+	public Edge[] getOutGoingEdges(Node u) {
+		return sortedOutGoingEdges.get(u); 
+	}
+	
+	public Edge[] getInComingEdges(Node u) {
+		return sortedInComingEdges.get(u);
+	}
+	
+	Comparator<Edge> edgeComp = new EdgeComparatorByNodeLabel(); 
+	
+	public Edge[] sort(Collection<Edge> edges) {
+		if (edges == null) return new Edge[0]; 
+		Edge[] sortedEdges = new Edge[edges.size()];
+		edges.toArray(sortedEdges); 
+		Arrays.sort(sortedEdges, edgeComp); 
+		return sortedEdges;
+	}
+	
+
+	private Comparator<Node> coarseNodeComparator = null; 
+
+	public Comparator<Node> getCoarseNodeComparator() {
+		if (coarseNodeComparator == null)
+			coarseNodeComparator = new EstimatedFeatureComparator(this); 
+		return coarseNodeComparator; 
+	}
+	
+	Map<String, Node> allNodes = new HashMap<String, Node>();
+	
+	private Node getNode(String nodeName) { 
+		Node node = null;
+		if ((node = allNodes.get(nodeName)) == null) {
+			node = new Node(nodeName); 
+			allNodes.put(nodeName, node);
+		}
+		return node; 
+	}
+	
+	private Node getNode(GroundTerm t) {
+		if (t instanceof uk.ac.ox.cs.JRDFox.model.Individual)
+			return getNode(((uk.ac.ox.cs.JRDFox.model.Individual) t).getIRI());
+		else {
+			Literal l = (Literal) t;
+			return getNode(l.getLexicalForm() + "^^" + l.getDatatype().getIRI());
+		}
+	}
+	
+	public Node getNode(Term t) {
+		if (t instanceof Individual)
+			return getNode(((Individual) t).getIRI()); 
+		else if (t instanceof Constant)
+			return getNode(((Constant) t).getLexicalForm() + "^^" + ((Constant) t).getDatatypeURI()); 
+		return null; 
+	}
+
+	public NodeTuple getNodeTuple(AnswerTuple tuple) {
+		NodeTuple ret = new NodeTuple(tuple); 
+		for (int i = 0; i < tuple.getArity(); ++i) 
+			ret.addNode(getNode(tuple.getGroundTerm(i)));
+		return ret;
+	}
+
+}
+
-- 
cgit v1.2.3