/** * Returns a concept's opposite one on a relation. * * @param c_curr the concept on the one end. * @param r_curr the relation. * @return the concept on the other end. */ private ONDEXConcept getOppositeConcept(ONDEXConcept c_curr, ONDEXRelation r_curr) { return (r_curr.getFromConcept().equals(c_curr)) ? r_curr.getToConcept() : r_curr.getFromConcept(); }
/** * Returns a concept's opposite one on a relation. * * @param c_curr the concept on the one end. * @param r_curr the relation. * @return the concept on the other end. */ private ONDEXConcept getOppositeConcept(ONDEXConcept c_curr, ONDEXRelation r_curr) { return (r_curr.getFromConcept().equals(c_curr)) ? r_curr.getToConcept() : r_curr.getFromConcept(); }
/** * Returns a concept's opposite one on a relation. * * @param c_curr * the concept on the one end. * @param r_curr * the relation. * @return the concept on the other end. */ private static ONDEXConcept getOppositeConcept(ONDEXConcept c_curr, ONDEXRelation r_curr) { return (r_curr.getFromConcept().equals(c_curr)) ? r_curr.getToConcept() : r_curr.getFromConcept(); }
private boolean containsEdge(ONDEXConcept f, ONDEXConcept t, Set<ONDEXRelation> rels) { for (ONDEXRelation r : rels) { if (r.getFromConcept().equals(f) && r.getToConcept().equals(t)) { return true; } } return false; }
private ONDEXConcept findEq(ONDEXConcept c, Set<ONDEXRelation> rels) { for (ONDEXRelation r : rels) { if (r.getFromConcept().equals(c)) { return r.getToConcept(); } else if (r.getToConcept().equals(c)) { return r.getFromConcept(); } } return null; }
@Override public Collection<ONDEXRelation> getOutEdges(ONDEXConcept vertex) { if (!containsVertex(vertex)) return null; Collection<ONDEXRelation> out = new HashSet<ONDEXRelation>(); for (ONDEXRelation edge : getRelationsOfConcept(vertex)) if (containsEdge(edge) && edge.getFromConcept().equals(vertex)) out.add(edge); return Collections.unmodifiableCollection(out); }
/** * Returns visibility for a given edge. * * @param edge * ONDEXRelation * @return is visible */ public boolean isVisible(ONDEXRelation edge) { if (edge == null) return false; return edge_visibility.get(edge.getId()) && vertex_visibility.get(edge.getFromConcept().getId()) && vertex_visibility.get(edge.getToConcept().getId()); }
public boolean isValidRelationAtDepth(ONDEXRelation relation, int currentPosition, ONDEXConcept conceptAtHead) { ONDEXConcept toConcept = relation.getToConcept(); if (toConcept.equals(conceptAtHead)) { toConcept = relation.getFromConcept(); } if (!isValidConceptAtDepth(toConcept, currentPosition)) return false; if (validRelationTypeAtDepth != null) { ArrayList<RelationType> list = validRelationTypeAtDepth.get(currentPosition); if (list != null) { if (list.contains(relation.getOfType())) return true; } else { return isInclusivePresumption; } } return false; }
public static void copyRelations(ONDEXGraph graph, ONDEXConcept copySource, ONDEXConcept copyTarget) { for (ONDEXRelation r : graph.getRelationsOfConcept(copySource)) { ONDEXConcept from = r.getFromConcept(); ONDEXConcept to = r.getToConcept(); if (from.equals(copySource)) { from = copyTarget; } else { to = copyTarget; } copyRelation(graph, from, to, r); } } }
private void recurseState(State s) throws InterruptedException { int nextDepth = s.depth + 1; for (ONDEXRelation r : og.getRelationsOfConcept(s.concept)) { if ((foundRelations.get(r) == null || nextDepth < foundRelations .get(r)) && validateRelationAtDepth(r, nextDepth, s.concept)) { foundRelations.put(r, nextDepth); addAndRecurseConcept(r.getFromConcept(), nextDepth); addAndRecurseConcept(r.getToConcept(), nextDepth); } } }
private static Set<ONDEXRelation> getRelationsWithAttribute(ONDEXGraph graph, ONDEXConcept c, AttributeName an) { BitSet set = new BitSet(); for (ONDEXRelation r : graph.getRelationsOfConcept(c)) { if (r.getFromConcept().equals(r.getToConcept())) continue; if (r.getAttribute(an) != null) set.set(r.getId()); } Set<ONDEXRelation> result = BitSetFunctions.create(graph, ONDEXRelation.class, set); return result; }
private void step() { boolean match = false; next = null; List<String> ofInterest = new ArrayList<String>(); while (!match && view.hasNext()) { ONDEXRelation r = view.next(); String[] cCvs = arrAnd(r.getFromConcept().getElementOf().getId().split(":"), r.getToConcept().getElementOf().getId().split(":"), validArgs); if (cCvs.length > 0) { match = true; next = cCvs; } } } }
@Override public Pair<ONDEXConcept> getEndpoints(ONDEXRelation edge) { if (!containsEdge(edge)) return null; Pair<ONDEXConcept> pair = new Pair<ONDEXConcept>(edge.getFromConcept(), edge.getToConcept()); return pair; }
private void propagate(BitSet toKeep, ONDEXConcept c, int l) throws NullValueException, AccessDeniedException { if (l > depth) return; if (toKeep.get(c.getId())) return; toKeep.set(c.getId()); for (ONDEXRelation r : graph.getRelationsOfConcept(c)) { if (!r.getToConcept().equals(c)) { propagate(toKeep, r.getToConcept(), l + 1); } else { propagate(toKeep, r.getFromConcept(), l + 1); } } }
/** * Constructor wraps a given ONDEXRelation. * * @param sid * unique id * @param aog * LuceneONDEXGraph * @param r * ONDEXRelation */ LuceneRelation(long sid, LuceneONDEXGraph aog, ONDEXRelation r) { this(sid, aog, r.getId(), r.getFromConcept(), r.getToConcept(), r .getOfType()); this.parent = r; }
/** * For a given relation returns the target concept, observes the reverse * logic flag. * * @param r * ONDEXRelation * @return target concept */ private ONDEXConcept getTarget(ONDEXRelation r) { String relationType = r.getOfType().getFullname(); if (relationType == null) relationType = r.getOfType().getId(); if (relationTypeReverseLogic.contains(relationType)) { return r.getFromConcept(); } return r.getToConcept(); }
/** * For a given relation returns the source concept, observes the reverse * logic flag. * * @param r * ONDEXRelation * @return source concept */ private ONDEXConcept getSource(ONDEXRelation r) { String relationType = r.getOfType().getFullname(); if (relationType == null) relationType = r.getOfType().getId(); if (relationTypeReverseLogic.contains(relationType)) { return r.getToConcept(); } return r.getFromConcept(); }
/** * Makes all of the relations visible, if their target and source are * currently visible */ public static void showConnectingRelations(OVTK2PropertiesAggregator viewer) { ONDEXJUNGGraph graph = viewer.getONDEXJUNGGraph(); for (ONDEXRelation r : graph.getRelations()) { ONDEXConcept c1 = r.getFromConcept(); ONDEXConcept c2 = r.getToConcept(); if (graph.isVisible(c1) && graph.isVisible(c2)) { graph.setVisibility(r, true); } } viewer.updateViewer(null); }
private void createEdgeForRelationType(RelationType rt) { // collect information on pairs of concept classes Set<Pair<ConceptClass>> betweenCC = new HashSet<Pair<ConceptClass>>(); for (ONDEXRelation r : graph.getRelationsOfRelationType(rt)) { ConceptClass from = r.getFromConcept().getOfType(); ConceptClass to = r.getToConcept().getOfType(); betweenCC.add(new Pair<ConceptClass>(from, to)); } // create meta relation for each pair for (Pair<ConceptClass> ccPair : betweenCC) { ONDEXMetaConcept from = new ONDEXMetaConcept(graph, ccPair.getFirst()); ONDEXMetaConcept to = new ONDEXMetaConcept(graph, ccPair.getSecond()); this.addEdge(new ONDEXMetaRelation(graph, rt, ccPair), new Pair<ONDEXMetaConcept>(from, to)); } this.fireStateChange(); }
public Model createModel(ONDEXGraph og) { Model instanceModel = ModelFactory.createDefaultModel(); for (ONDEXConcept concept : og.getConcepts()) { Resource classOfConcept = instanceModel.createResource(urlPrefixMetaData + concept.getOfType().getId()); instanceModel.createResource(urlPrefixInstances + concept.getId(), classOfConcept); } for (ONDEXRelation or : og.getRelations()) { Property propertyOfPredicate = instanceModel.createProperty(urlPrefixMetaData, or.getOfType().getId()); Resource fromConcept = instanceModel.getResource(urlPrefixInstances + or.getFromConcept().getId()); Resource toConcept = instanceModel.getResource(urlPrefixInstances + or.getToConcept().getId()); instanceModel.createStatement(toConcept, propertyOfPredicate, fromConcept); } return instanceModel; }