initial version

1 files changed, 154 insertions, 0 deletions

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;
+        }
+
+}
+