private Map<String, SemanticTypeNode> createDomainNodeMap() { Map<String, SemanticTypeNode> hNodeIdToDomainNodeMap = new HashMap<>(); Set<Node> alignmentColumnNodes = alignment.getNodesByType(NodeType.ColumnNode); if (alignmentColumnNodes == null) return hNodeIdToDomainNodeMap; for (Node cNode : alignmentColumnNodes) { Set<LabeledLink> incomingLinks = alignment.getCurrentIncomingLinksToNode(cNode.getId()); if (incomingLinks != null && !incomingLinks.isEmpty()) { LabeledLink incomingLink = alignment.getCurrentIncomingLinksToNode(cNode.getId()).iterator().next(); if (incomingLink != null && incomingLink.getSource() instanceof InternalNode) { String hNodeId = ((ColumnNode) cNode).getHNodeId(); if (incomingLink instanceof DataPropertyOfColumnLink || incomingLink instanceof ObjectPropertySpecializationLink) { String id; if (incomingLink instanceof DataPropertyOfColumnLink) id = ((DataPropertyOfColumnLink) incomingLink).getSpecializedLinkId(); else id = ((ObjectPropertySpecializationLink) incomingLink).getSpecializedLinkId(); hNodeIdToDomainNodeMap.put( hNodeId, new SemanticTypeNode( id, id, id, incomingLink.getLabel().getRdfsLabel(), incomingLink.getLabel().getRdfsComment())); } else { InternalNode source = (InternalNode) incomingLink.getSource(); hNodeIdToDomainNodeMap.put( hNodeId, new SemanticTypeNode( source.getId(), source.getUri(), source.getDisplayId(), source.getLabel().getRdfsLabel(), source.getLabel().getRdfsComment())); } } } } return hNodeIdToDomainNodeMap; }
private Set<SemanticTypeMapping> findSemanticTypeInGraph( ColumnNode sourceColumn, SemanticType semanticType, HashMap<String, Integer> semanticTypesCount, Set<Node> addedNodes) { logger.debug("finding matches for semantic type in the graph ... "); if (addedNodes == null) addedNodes = new HashSet<Node>(); Set<SemanticTypeMapping> mappings = new HashSet<SemanticTypeMapping>(); if (semanticType == null) { logger.error("semantic type is null."); return mappings; } if (semanticType.getDomain() == null) { logger.error("semantic type does not have any domain"); return mappings; } if (semanticType.getType() == null) { logger.error("semantic type does not have any link"); return mappings; } String domainUri = semanticType.getDomain().getUri(); String propertyUri = semanticType.getType().getUri(); Double confidence = semanticType.getConfidenceScore(); Origin origin = semanticType.getOrigin(); Integer countOfSemanticType = semanticTypesCount.get(domainUri + propertyUri); if (countOfSemanticType == null) { logger.error("count of semantic type should not be null or zero"); return mappings; } if (domainUri == null || domainUri.isEmpty()) { logger.error("semantic type does not have any domain"); return mappings; } if (propertyUri == null || propertyUri.isEmpty()) { logger.error("semantic type does not have any link"); return mappings; } logger.debug( "semantic type: " + domainUri + "|" + propertyUri + "|" + confidence + "|" + origin); // add dataproperty to existing classes if sl is a data node mapping // Set<Node> foundInternalNodes = new HashSet<Node>(); Set<SemanticTypeMapping> semanticTypeMatches = this.graphBuilder.getSemanticTypeMatches().get(domainUri + propertyUri); if (semanticTypeMatches != null) { for (SemanticTypeMapping stm : semanticTypeMatches) { SemanticTypeMapping mp = new SemanticTypeMapping( sourceColumn, semanticType, stm.getSource(), stm.getLink(), stm.getTarget()); mappings.add(mp); // foundInternalNodes.add(stm.getSource()); } } logger.debug("adding data property to the found internal nodes ..."); Integer count; boolean allowMultipleSamePropertiesPerNode = ModelingConfigurationRegistry.getInstance() .getModelingConfiguration( ContextParametersRegistry.getInstance() .getContextParameters(ontologyManager.getContextId()) .getKarmaHome()) .isMultipleSamePropertyPerNode(); Set<Node> nodesWithSameUriOfDomain = this.graphBuilder.getUriToNodesMap().get(domainUri); if (nodesWithSameUriOfDomain != null) { for (Node source : nodesWithSameUriOfDomain) { count = this.graphBuilder.getNodeDataPropertyCount().get(source.getId() + propertyUri); if (count != null) { if (allowMultipleSamePropertiesPerNode) { if (count >= countOfSemanticType.intValue()) continue; } else { if (count >= 1) continue; } } String nodeId = new RandomGUID().toString(); ColumnNode target = new ColumnNode(nodeId, nodeId, sourceColumn.getColumnName(), null); if (!this.graphBuilder.addNode(target)) continue; ; addedNodes.add(target); String linkId = LinkIdFactory.getLinkId(propertyUri, source.getId(), target.getId()); LabeledLink link = new DataPropertyLink(linkId, new Label(propertyUri)); if (!this.graphBuilder.addLink(source, target, link)) continue; ; SemanticTypeMapping mp = new SemanticTypeMapping( sourceColumn, semanticType, (InternalNode) source, link, target); mappings.add(mp); } } return mappings; }
@Override public void generateJson(String prefix, PrintWriter pw, VWorkspace vWorkspace) { VWorksheet vWorksheet = vWorkspace.getViewFactory().getVWorksheetByWorksheetId(worksheetId); List<String> hNodeIdList = new ArrayList<String>(); List<HNodePath> columns = vWorksheet.getColumns(); for (HNodePath path : columns) hNodeIdList.add(path.getLeaf().getId()); String alignmentId = AlignmentManager.Instance() .constructAlignmentId(vWorkspace.getWorkspace().getId(), vWorksheet.getWorksheetId()); JSONObject topObj = new JSONObject(); try { topObj.put( GenericJsonKeys.updateType.name(), AlignmentSVGVisualizationUpdate.class.getSimpleName()); topObj.put(JsonKeys.alignmentId.name(), alignmentId); topObj.put(JsonKeys.worksheetId.name(), worksheetId); // Using Mohsen's GraphUtils method for graph traversal HashMap<Node, Integer> nodeHeightsMap = GraphUtil.levelingCyclicGraph(alignmentGraph); HashMap<Node, Set<ColumnNode>> nodeCoverage = GraphUtil.getNodesCoverage(alignmentGraph, nodeHeightsMap); /** Identify the max height * */ int maxTreeHeight = 0; for (Node node : nodeHeightsMap.keySet()) { if (nodeHeightsMap.get(node) >= maxTreeHeight) { maxTreeHeight = nodeHeightsMap.get(node); } } /** * Add the nodes and the links from the Steiner tree ** */ List<String> hNodeIdsAdded = new ArrayList<String>(); JSONArray nodesArr = new JSONArray(); JSONArray linksArr = new JSONArray(); if (alignmentGraph != null && alignmentGraph.vertexSet().size() != 0) { /** Add the nodes * */ Set<Node> nodes = alignmentGraph.vertexSet(); HashMap<Node, Integer> verticesIndex = new HashMap<Node, Integer>(); int nodesIndexcounter = 0; for (Node node : nodes) { /** Get info about the nodes that this node covers or sits above * */ int height = maxTreeHeight - nodeHeightsMap.get(node); /** Add the hnode ids of the columns that this vertex covers * */ JSONArray hNodeIdsCoveredByVertex = new JSONArray(); for (Node v : nodeCoverage.get(node)) { if (v instanceof ColumnNode) { ColumnNode cNode = (ColumnNode) v; hNodeIdsCoveredByVertex.put(cNode.getHNodeId()); } } String hNodeId = ""; /** Add the semantic type information * */ if (node instanceof ColumnNode) { ColumnNode cNode = (ColumnNode) node; hNodeId = cNode.getHNodeId(); hNodeIdsAdded.add(cNode.getHNodeId()); } JSONObject nodeObj = getNodeJsonObject( node.getLocalId(), node.getId(), node.getType().name(), height, hNodeIdsCoveredByVertex, hNodeId); nodesArr.put(nodeObj); verticesIndex.put(node, nodesIndexcounter++); } /** * Add the links ** */ Set<Link> links = alignmentGraph.edgeSet(); for (Link link : links) { Node source = link.getSource(); Integer sourceIndex = verticesIndex.get(source); Node target = link.getTarget(); Integer targetIndex = verticesIndex.get(target); Set<Link> outEdges = alignmentGraph.outgoingEdgesOf(target); if (sourceIndex == null || targetIndex == null) { logger.error("Edge vertex index not found!"); continue; } JSONObject linkObj = new JSONObject(); linkObj.put(JsonKeys.source.name(), sourceIndex); linkObj.put(JsonKeys.target.name(), targetIndex); linkObj.put(JsonKeys.sourceNodeId.name(), source.getId()); linkObj.put(JsonKeys.targetNodeId.name(), target.getId()); linkObj.put(JsonKeys.label.name(), link.getLabel().getLocalName()); linkObj.put(JsonKeys.id.name(), link.getId() + ""); linkObj.put(JsonKeys.linkStatus.name(), link.getStatus().name()); linkObj.put(JsonKeys.linkUri.name(), link.getLabel().getUri()); if (target.getType() == NodeType.ColumnNode && outEdges.isEmpty()) { linkObj.put(JsonKeys.linkType.name(), JsonValues.holderLink.name()); if (link.getKeyType() == LinkKeyInfo.PartOfKey) linkObj.put(JsonKeys.label.name(), link.getLabel().getLocalName() + "*"); } linksArr.put(linkObj); if (link.getType() == LinkType.ClassInstanceLink && link.getKeyType() == LinkKeyInfo.PartOfKey && target instanceof ColumnNode) { ColumnNode cNode = (ColumnNode) target; // Add the holder vertex object and the link that attaches nodes to the columns JSONArray hNodeIdsCoveredByVertex_holder = new JSONArray(); hNodeIdsCoveredByVertex_holder.put(cNode.getHNodeId()); JSONObject vertObj_holder = getNodeJsonObject( JsonValues.key.name(), source.getId() + "_holder", NodeType.ColumnNode.name(), 0, hNodeIdsCoveredByVertex_holder, cNode.getHNodeId()); nodesArr.put(vertObj_holder); nodesIndexcounter++; // Add the holder link JSONObject linkObj_holder = getLinkJsonObject( JsonValues.key.name(), "", nodesIndexcounter, nodesIndexcounter - 1, "", "", "", ""); linksArr.put(linkObj_holder); } if (link.getType() == LinkType.DataPropertyOfColumnLink) { DataPropertyOfColumnLink dpLink = (DataPropertyOfColumnLink) link; String startHNodeId = dpLink.getSpecializedColumnHNodeId(); // Get height of the class instance node int height = maxTreeHeight - nodeHeightsMap.get(link.getSource()); // Add 2 more holder nodes // Start node JSONArray hNodeIdsCoveredByVertex_holder = new JSONArray(); hNodeIdsCoveredByVertex_holder.put(startHNodeId); JSONObject startNode = getNodeJsonObject( "", source.getId() + "_holder", JsonValues.DataPropertyOfColumnHolder.name(), height - 0.35, hNodeIdsCoveredByVertex_holder, startHNodeId); nodesArr.put(startNode); nodesIndexcounter++; // End node String endHNodeId = ((ColumnNode) link.getTarget()).getHNodeId(); JSONArray hNodeIdsCoveredByVertex_holder_2 = new JSONArray(); hNodeIdsCoveredByVertex_holder_2.put(endHNodeId); JSONObject endNode = getNodeJsonObject( "", target.getId() + "_holder", JsonValues.DataPropertyOfColumnHolder.name(), height - 0.35, hNodeIdsCoveredByVertex_holder_2, endHNodeId); nodesArr.put(endNode); nodesIndexcounter++; // Add the horizontal link JSONObject linkObj_holder = getLinkJsonObject( "", "", nodesIndexcounter - 2, nodesIndexcounter - 1, JsonValues.horizontalDataPropertyLink.name(), "", "", ""); linksArr.put(linkObj_holder); } else if (link.getType() == LinkType.ObjectPropertySpecializationLink) { ObjectPropertySpecializationLink opLink = (ObjectPropertySpecializationLink) link; Link specializedLink = opLink.getSpecializedLink(); // Get height of the class instance node int height = nodeHeightsMap.get(specializedLink.getTarget()); // Add 2 more holder nodes // Start node JSONArray hNodeIdsCoveredByVertex_holder = new JSONArray(); for (Node v : nodeCoverage.get(specializedLink.getTarget())) { if (v instanceof ColumnNode) { ColumnNode cNode = (ColumnNode) v; hNodeIdsCoveredByVertex_holder.put(cNode.getHNodeId()); } } JSONObject startNode = getNodeJsonObject( "", source.getId() + "_holder", JsonValues.DataPropertyOfColumnHolder.name(), height + 0.65, hNodeIdsCoveredByVertex_holder, ""); nodesArr.put(startNode); nodesIndexcounter++; // End node String endHNodeId = ((ColumnNode) link.getTarget()).getHNodeId(); JSONArray hNodeIdsCoveredByVertex_holder_2 = new JSONArray(); hNodeIdsCoveredByVertex_holder_2.put(endHNodeId); JSONObject endNode = getNodeJsonObject( "", target.getId() + "_holder", JsonValues.DataPropertyOfColumnHolder.name(), height + 0.65, hNodeIdsCoveredByVertex_holder_2, endHNodeId); nodesArr.put(endNode); nodesIndexcounter++; // Add the horizontal link JSONObject linkObj_holder = getLinkJsonObject( "", "", nodesIndexcounter - 2, nodesIndexcounter - 1, JsonValues.horizontalDataPropertyLink.name(), "", "", ""); linksArr.put(linkObj_holder); } linkObj.put(JsonKeys.linkType.name(), link.getType()); } } // Add the vertices for the columns that were not in Steiner tree hNodeIdList.removeAll(hNodeIdsAdded); for (String hNodeId : hNodeIdList) { JSONArray hNodeIdsCoveredByVertex = new JSONArray(); hNodeIdsCoveredByVertex.put(hNodeId); JSONObject vertObj = getNodeJsonObject( "", hNodeId, JsonValues.Unassigned.name(), 0, hNodeIdsCoveredByVertex, hNodeId); nodesArr.put(vertObj); } topObj.put(JsonKeys.maxTreeHeight.name(), maxTreeHeight); topObj.put(JsonKeys.nodes.name(), nodesArr); topObj.put(JsonKeys.links.name(), linksArr); pw.write(topObj.toString()); } catch (JSONException e) { logger.error("Error occured while writing JSON!", e); } }
private static DirectedWeightedMultigraph<Node, LabeledLink> buildGraphsFromStatements2( List<Statement> statements) { if (statements == null || statements.size() == 0) return null; DirectedWeightedMultigraph<Node, LabeledLink> graph = new DirectedWeightedMultigraph<Node, LabeledLink>(LabeledLink.class); // Assumption: there is only one rdf:type for each URI HashMap<String, Node> uri2Classes = new HashMap<String, Node>(); for (Statement st : statements) { String subjStr = st.getSubject(); String predicateStr = st.getPredicate(); String objStr = st.getObject(); subjStr = getUri(subjStr); predicateStr = getUri(predicateStr); objStr = getUri(objStr); if (predicateStr.equalsIgnoreCase(typePredicate)) { Node classNode = new InternalNode(objStr, new Label(objStr)); uri2Classes.put(subjStr, classNode); graph.addVertex(classNode); } } // int countOfLiterals = 0; String id; for (Statement st : statements) { String subjStr = st.getSubject(); String predicateStr = st.getPredicate(); String objStr = st.getObject(); subjStr = getUri(subjStr); predicateStr = getUri(predicateStr); objStr = getUri(objStr); if (predicateStr.equalsIgnoreCase(typePredicate)) continue; Node subj = uri2Classes.get(subjStr); if (subj == null) { subj = new InternalNode(subjStr, new Label(subjStr)); graph.addVertex(subj); } Node obj = uri2Classes.get(objStr); if (obj == null) { if (objStr.startsWith(attPrefix)) { id = new RandomGUID().toString(); obj = new ColumnNode(id, objStr, objStr, null, null); SemanticType semanticType = new SemanticType( ((ColumnNode) obj).getHNodeId(), new Label(predicateStr), subj.getLabel(), Origin.User, 1.0, false); ((ColumnNode) obj).setUserSelectedSemanticType(semanticType); } else if (objStr.indexOf(":") == -1 && objStr.indexOf("\"") != -1) { // String literalId = "lit:" + serviceId + "_l" + String.valueOf(countOfLiterals); obj = new LiteralNode(objStr, objStr, null); // countOfLiterals ++; } else obj = new InternalNode(objStr, new Label(objStr)); graph.addVertex(obj); } LabeledLink e; if (obj instanceof InternalNode) e = new ObjectPropertyLink( LinkIdFactory.getLinkId(predicateStr, subj.getId(), obj.getId()), new Label(predicateStr), ObjectPropertyType.None); else e = new DataPropertyLink( LinkIdFactory.getLinkId(predicateStr, subj.getId(), obj.getId()), new Label(predicateStr)); graph.addEdge(subj, obj, e); } return graph; }
@Override public UpdateContainer doIt(Workspace workspace) throws CommandException { final OntologyManager ontMgr = workspace.getOntologyManager(); Set<LabeledLink> properties = new HashSet<>(); logger.debug( "GetPropertiesCommand:" + propertiesRange + ":" + classURI + "," + domainURI + ", " + rangeURI); if (propertiesRange == INTERNAL_PROP_RANGE.allObjectProperties) { HashMap<String, Label> linkList = ontMgr.getObjectProperties(); if (linkList != null) { for (Label label : linkList.values()) { properties.add(new DataPropertyLink(label.getUri(), label)); } } } else if (propertiesRange == INTERNAL_PROP_RANGE.allDataProperties) { HashMap<String, Label> linkList = ontMgr.getDataProperties(); for (Label label : linkList.values()) { properties.add(new DataPropertyLink(label.getUri(), label)); } } else if (propertiesRange == INTERNAL_PROP_RANGE.propertiesWithDomainRange) { Map<String, Label> linkList = ontMgr.getObjectPropertiesByDomainRange(domainURI, rangeURI, true); for (Label label : linkList.values()) { properties.add(new DataPropertyLink(label.getUri(), label)); } } else if (propertiesRange == INTERNAL_PROP_RANGE.dataPropertiesForClass) { Map<String, Label> linkList = ontMgr.getDataPropertiesByDomain(classURI, true); for (Label label : linkList.values()) { properties.add(new DataPropertyLink(label.getUri(), label)); } } else if (propertiesRange == INTERNAL_PROP_RANGE.existingProperties) { Alignment alignment = AlignmentManager.Instance() .getAlignmentOrCreateIt(workspace.getId(), worksheetId, ontMgr); Set<String> steinerTreeNodeIds = new HashSet<String>(); if (alignment != null && !alignment.isEmpty()) { DirectedWeightedMultigraph<Node, LabeledLink> steinerTree = alignment.getSteinerTree(); for (Node node : steinerTree.vertexSet()) { if (node.getType() == NodeType.InternalNode) { steinerTreeNodeIds.add(node.getId()); } } List<LabeledLink> specializedLinks = new ArrayList<LabeledLink>(); Set<LabeledLink> temp = null; temp = alignment.getLinksByType(LinkType.DataPropertyLink); if (temp != null) specializedLinks.addAll(temp); for (LabeledLink link : steinerTree.edgeSet()) if (link instanceof ObjectPropertyLink) specializedLinks.add(link); // Store the data property links for specialized edge link options properties.addAll(specializedLinks); } } logger.debug("Got back " + properties.size() + " results"); final Set<LabeledLink> finalProperties = properties; UpdateContainer upd = new UpdateContainer( new AbstractUpdate() { @Override public void generateJson(String prefix, PrintWriter pw, VWorkspace vWorkspace) { JSONObject obj = new JSONObject(); JSONArray resultArray = new JSONArray(); try { obj.put(JsonKeys.updateType.name(), "PropertyList"); for (LabeledLink link : finalProperties) { Label linkLabel = link.getLabel(); String edgeLabelStr = linkLabel.getDisplayName(); JSONObject edgeObj = new JSONObject(); if (linkLabel.getUri() != null && linkLabel.getNs() != null && linkLabel.getUri().equalsIgnoreCase(linkLabel.getNs())) { edgeLabelStr = linkLabel.getUri(); } edgeObj.put(JsonKeys.label.name(), edgeLabelStr); edgeObj.put(JsonKeys.uri.name(), linkLabel.getUri()); edgeObj.put(JsonKeys.id.name(), link.getId()); resultArray.put(edgeObj); } obj.put(JsonKeys.properties.name(), resultArray); pw.println(obj.toString()); } catch (Exception e) { logger.error("Exception:", e); e.printStackTrace(); } } }); return upd; }