Examples with SNode org.corpus_tools.salt.core.SNode used on opensource projects

Example 6 with SNode

use of org.corpus_tools.salt.core.SNode in project ANNIS by korpling.

the class Helper method calulcateColorsForMarkedAndCovered.

public static void calulcateColorsForMarkedAndCovered(SDocument result, Map<String, Long> markedAndCovered, Map<String, String> markedCoveredMap) {
    if (markedAndCovered != null) {
        for (Map.Entry<String, Long> markedEntry : markedAndCovered.entrySet()) {
            int color = Math.max(0, Math.min((int) markedEntry.getValue().longValue() - 1, MatchedNodeColors.values().length - 1));
            SNode n = result.getDocumentGraph().getNode(markedEntry.getKey());
            RelannisNodeFeature feat = RelannisNodeFeature.extract(n);
            if (feat != null) {
                markedCoveredMap.put("" + feat.getInternalID(), MatchedNodeColors.values()[color].name());
            }
        }
    // end for each entry in markedAndCoverd
    }
// end if markedAndCovered not null
}

Example 7 with SNode

use of org.corpus_tools.salt.core.SNode in project ANNIS by korpling.

the class ResolverProviderImpl method getResolverEntries.

@Override
public ResolverEntry[] getResolverEntries(SDocument doc) {
    HashSet<ResolverEntry> visSet = new HashSet<ResolverEntry>();
    // create a request for resolver entries
    HashSet<SingleResolverRequest> resolverRequests = new HashSet<SingleResolverRequest>();
    Set<String> nodeLayers = new HashSet<String>();
    for (SNode n : doc.getDocumentGraph().getNodes()) {
        for (SLayer layer : n.getLayers()) {
            nodeLayers.add(layer.getName());
        }
    }
    Set<String> edgeLayers = new HashSet<String>();
    for (SRelation<SNode, SNode> e : doc.getDocumentGraph().getRelations()) {
        for (SLayer layer : e.getLayers()) {
            try {
                edgeLayers.add(layer.getName());
            } catch (NullPointerException ex) {
                log.warn("NullPointerException when using Salt, was trying to get layer name", ex);
            }
        }
    }
    for (String ns : nodeLayers) {
        resolverRequests.add(new SingleResolverRequest(doc.getGraph().getRoots().get(0).getName(), ns, ResolverEntry.ElementType.node));
    }
    for (String ns : edgeLayers) {
        resolverRequests.add(new SingleResolverRequest(doc.getGraph().getRoots().get(0).getName(), ns, ResolverEntry.ElementType.edge));
    }
    // query with this resolver request and make sure it is unique
    if (cacheResolver.containsKey(resolverRequests)) {
        visSet.addAll(cacheResolver.get(resolverRequests));
    } else {
        List<ResolverEntry> resolverList = new LinkedList<ResolverEntry>();
        WebResource resResolver = Helper.getAnnisWebResource().path("query").path("resolver");
        for (SingleResolverRequest r : resolverRequests) {
            List<ResolverEntry> tmp;
            String corpusName = urlPathEscape.escape(r.getCorpusName());
            String namespace = r.getNamespace();
            String type = r.getType() == null ? null : r.getType().toString();
            if (corpusName != null && namespace != null && type != null) {
                WebResource res = resResolver.path(corpusName).path(namespace).path(type);
                try {
                    tmp = res.get(new ResolverEntryListType());
                    resolverList.addAll(tmp);
                } catch (UniformInterfaceException | ClientHandlerException ex) {
                    if (!AnnisBaseUI.handleCommonError(ex, "query resolver entries")) {
                        log.error("could not query resolver entries: " + res.toString(), ex);
                    }
                }
            }
        }
        visSet.addAll(resolverList);
        cacheResolver.put(resolverRequests, resolverList);
    }
    // sort everything
    ResolverEntry[] visArray = visSet.toArray(new ResolverEntry[visSet.size()]);
    Arrays.sort(visArray, new ResolverEntryComparator());
    return visArray;
}

Example 8 with SNode

use of org.corpus_tools.salt.core.SNode in project ANNIS by korpling.

the class AutoSimpleRegexQuery method analyzingQuery.

@Override
public void analyzingQuery(SaltProject saltProject) {
    List<String> tokens = new ArrayList<>();
    for (SCorpusGraph g : saltProject.getCorpusGraphs()) {
        if (g != null) {
            for (SDocument doc : g.getDocuments()) {
                SDocumentGraph docGraph = doc.getDocumentGraph();
                List<SNode> sNodes = docGraph.getNodes();
                if (sNodes != null) {
                    for (SNode n : sNodes) {
                        if (n instanceof SToken) {
                            tokens.add(CommonHelper.getSpannedText((SToken) n));
                        }
                    }
                }
            }
        }
    }
    // try to find a word with which is contained twice with Capitalize letter.
    text = null;
    for (int i = 0; i < tokens.size(); i++) {
        for (int j = i + 1; j < tokens.size(); j++) {
            if (tokens.get(i).equalsIgnoreCase(tokens.get(j))) {
                if (tokens.get(i).length() > 1 && ((Character.isLowerCase(tokens.get(i).charAt(0)) && Character.isUpperCase(tokens.get(j).charAt(0))) || (Character.isLowerCase(tokens.get(j).charAt(0)) && Character.isUpperCase(tokens.get(i).charAt(0))))) {
                    text = tokens.get(i);
                    break;
                }
            }
        }
    }
    if (text != null) {
        Character upperLetter = Character.toUpperCase(text.charAt(0));
        Character lowerLetter = Character.toLowerCase(text.charAt(0));
        String rest = StringUtils.substring(text, -(text.length() - 1));
        finalAQL = "/[" + upperLetter + lowerLetter + "]" + rest + "/";
    } else {
        // select one random token from the result
        int tries = 10;
        int r = new Random().nextInt(tokens.size() - 1);
        text = tokens.get(r);
        while ("".equals(text) && tries > 0) {
            r = new Random().nextInt(tokens.size() - 1);
            text = tokens.get(r);
            tries--;
        }
        if (!"".equals(text) && text.length() > 1) {
            Character upperLetter = Character.toUpperCase(text.charAt(0));
            Character lowerLetter = Character.toLowerCase(text.charAt(0));
            String rest = StringUtils.substring(text, -(text.length() - 1));
            finalAQL = "/[" + upperLetter + lowerLetter + "]" + rest + "/";
        } else {
            finalAQL = "";
        }
    }
}

Example 9 with SNode

use of org.corpus_tools.salt.core.SNode in project ANNIS by korpling.

the class SaltAnnotateExtractor method createNewRelation.

private SRelation createNewRelation(SDocumentGraph graph, SStructuredNode sourceNode, SNode targetNode, String relationName, String type, long componentID, SLayer layer, long pre, FastInverseMap<Long, SNode> nodeByRankID, AtomicInteger numberOfRelations) {
    SRelation rel = null;
    if (null != type) // create new relation
    {
        switch(type) {
            case "d":
                SDominanceRelation domrel = SaltFactory.createSDominanceRelation();
                // always set a name by ourself since the SDocumentGraph#basicAddRelation()
                // functions otherwise real slow
                domrel.setName("sDomRel" + numberOfRelations.incrementAndGet());
                rel = domrel;
                if (sourceNode != null && !(sourceNode instanceof SStructure)) {
                    log.debug("Mismatched source type: should be SStructure");
                    SNode oldNode = sourceNode;
                    sourceNode = recreateNode(SStructure.class, sourceNode);
                    updateMapAfterRecreatingNode(oldNode, sourceNode, nodeByRankID);
                }
                if (relationName == null || relationName.isEmpty()) {
                    // layer but has a non-empty relation name
                    if (handleArtificialDominanceRelation(graph, sourceNode, targetNode, rel, layer, componentID, pre)) {
                        // don't include this relation
                        rel = null;
                    }
                }
                break;
            case "c":
                SSpanningRelation spanrel = SaltFactory.createSSpanningRelation();
                // always set a name by ourself since the SDocumentGraph#basicAddRelation()
                // functions is real slow otherwise
                spanrel.setName("sSpanRel" + numberOfRelations.incrementAndGet());
                rel = spanrel;
                sourceNode = testAndFixNonSpan(sourceNode, nodeByRankID);
                break;
            case "p":
                SPointingRelation pointingrel = SaltFactory.createSPointingRelation();
                pointingrel.setName("sPointingRel" + numberOfRelations.incrementAndGet());
                rel = pointingrel;
                break;
            default:
                throw new IllegalArgumentException("Invalid type " + type + " for new Relation");
        }
        try {
            if (rel != null) {
                rel.setType(relationName);
                RelannisEdgeFeature featRelation = new RelannisEdgeFeature();
                featRelation.setPre(pre);
                featRelation.setComponentID(componentID);
                SFeature sfeatRelation = SaltFactory.createSFeature();
                sfeatRelation.setNamespace(ANNIS_NS);
                sfeatRelation.setName(FEAT_RELANNIS_EDGE);
                sfeatRelation.setValue(featRelation);
                rel.addFeature(sfeatRelation);
                rel.setSource(sourceNode);
                if ("c".equals(type) && !(targetNode instanceof SToken)) {
                    log.warn("invalid relation detected: target node ({}) " + "of a coverage relation (from: {}, internal id {}) was not a token", new Object[] { targetNode.getName(), sourceNode == null ? "null" : sourceNode.getName(), "" + pre });
                } else {
                    rel.setTarget(targetNode);
                    graph.addRelation(rel);
                    layer.addRelation(rel);
                }
            }
        } catch (SaltException ex) {
            log.warn("invalid relation detected", ex);
        }
    }
    return rel;
}

Example 10 with SNode

use of org.corpus_tools.salt.core.SNode in project ANNIS by korpling.

the class TextColumnExporter method createAdjacencyMatrix.

/**
 * Implements the abstract method of the [SaltBasedExporter](\ref annis.gui.exporter.SaltBasedExporter).
 * This method creates and fills an adjacency matrix of dimension (nodeCount x nodeCount), which keeps the relative order
 * of match numbers to each other of each query result line. A result line is a part of a record, which belongs to a speaker.
 *
 * The adjacency matrix is a global two-dimensional array of integers, which allows to recognize the valid order of match numbers globally, after all query results are processed.
 *
 * @param graph  an org.corpus_tools.salt.common.SDocumentGraph representation of a record
 * @param args a map containing parameters like 'filter' or 'metakeys', set by user
 * @param recordNumber the number of record within  the record set returned for the user query
 * @param nodeCount the count of distinct match numbers in the whole record set returned for the user query
 */
@Override
public void createAdjacencyMatrix(SDocumentGraph graph, Map<String, String> args, int recordNumber, int nodeCount) throws IOException {
    String currSpeakerName = "";
    String prevSpeakerName = "";
    List<Long> matchNumbersOrdered = new ArrayList<Long>();
    // if new search, reset adjacencyMatrix, extract parameters, set by user
    if (recordNumber == 0) {
        speakerHasMatches.clear();
        speakerName = "";
        tokenToMatchNumber.clear();
        filterNumbersSetByUser.clear();
        filterNumbersIsEmpty = true;
        listOfMetakeys.clear();
        adjacencyMatrix = new int[nodeCount][nodeCount];
        matrixIsFilled = false;
        singleMatchesGlobal.clear();
        orderedMatchNumbersGlobal.clear();
        matchNumbersGlobal.clear();
        dataIsAlignable = true;
        maxMatchesPerLine = 0;
        // initialize adjacency matrix
        for (int i = 0; i < adjacencyMatrix.length; i++) {
            for (int j = 0; j < adjacencyMatrix[0].length; j++) {
                adjacencyMatrix[i][j] = -1;
            }
        }
        // extract filter numbers, if set
        if (args.containsKey(FILTER_PARAMETER_KEYWORD)) {
            String parameters = args.get(FILTER_PARAMETER_KEYWORD);
            String[] numbers = parameters.split(PARAMETER_SEPARATOR);
            for (int i = 0; i < numbers.length; i++) {
                try {
                    Long number = Long.parseLong(numbers[i]);
                    filterNumbersSetByUser.add(number);
                } catch (NumberFormatException e) {
                    ;
                }
            }
        }
        if (!filterNumbersSetByUser.isEmpty()) {
            filterNumbersIsEmpty = false;
        }
        // extract metakeys
        if (args.containsKey(METAKEYS_KEYWORD)) {
            String parameters = args.get(METAKEYS_KEYWORD);
            String[] metakeys = parameters.split(PARAMETER_SEPARATOR);
            for (int i = 0; i < metakeys.length; i++) {
                String metakey = metakeys[i].trim();
                listOfMetakeys.add(metakey);
            }
        }
    }
    if (graph != null) {
        List<SToken> orderedToken = graph.getSortedTokenByText();
        // iterate over all token
        if (orderedToken != null) {
            // reset counter over all the tokens
            if (recordNumber == 0) {
                counterGlobal = 0;
            }
            // iterate first time over tokens to figure out which speaker has matches and to recognize the hierarchical structure of matches as well
            for (SToken token : orderedToken) {
                counterGlobal++;
                String name;
                if ((name = CommonHelper.getTextualDSForNode(token, graph).getName()) == null) {
                    name = "";
                }
                speakerName = (recordNumber + 1) + "_" + name;
                currSpeakerName = speakerName;
                // reset data structures for new speaker
                if (!currSpeakerName.equals(prevSpeakerName)) {
                    matchNumbersOrdered.clear();
                }
                if (!speakerHasMatches.containsKey(currSpeakerName)) {
                    speakerHasMatches.put(currSpeakerName, false);
                }
                List<SNode> root = new LinkedList<>();
                root.add(token);
                IsDominatedByMatch traverserSpeakerSearch = new IsDominatedByMatch();
                // reset list
                dominatedMatchCodes.clear();
                graph.traverse(root, GRAPH_TRAVERSE_TYPE.BOTTOM_UP_DEPTH_FIRST, TRAV_PREPROCESSING, traverserSpeakerSearch);
                if (!dominatedMatchCodes.isEmpty()) {
                    // if filter numbers not set by user, take the number of the highest match node
                    if (filterNumbersIsEmpty) {
                        tokenToMatchNumber.put(counterGlobal, dominatedMatchCodes.get(dominatedMatchCodes.size() - 1));
                        // set filter number to the ordered list
                        if (!matchNumbersOrdered.contains(dominatedMatchCodes.get(dominatedMatchCodes.size() - 1))) {
                            matchNumbersOrdered.add(dominatedMatchCodes.get(dominatedMatchCodes.size() - 1));
                        }
                    } else {
                        // take the highest match code, which is present in filterNumbers
                        boolean filterNumberFound = false;
                        for (int i = dominatedMatchCodes.size() - 1; i >= 0; i--) {
                            if (filterNumbersSetByUser.contains(dominatedMatchCodes.get(i))) {
                                tokenToMatchNumber.put(counterGlobal, dominatedMatchCodes.get(i));
                                if (!matchNumbersOrdered.contains(dominatedMatchCodes.get(i))) {
                                    if (!filterNumberFound) {
                                        matchNumbersOrdered.add(dominatedMatchCodes.get(i));
                                        filterNumberFound = true;
                                    }
                                }
                                break;
                            }
                        }
                    }
                    // reset maxMatchesPerLine
                    if (maxMatchesPerLine < matchNumbersOrdered.size()) {
                        maxMatchesPerLine = matchNumbersOrdered.size();
                    }
                    // fill the adjacency matrix
                    if (matchNumbersOrdered.size() > 1) {
                        Iterator<Long> it = matchNumbersOrdered.iterator();
                        int prev = Integer.parseInt(String.valueOf((Long) it.next()));
                        matchNumbersGlobal.add(prev);
                        while (it.hasNext()) {
                            int curr = Integer.parseInt(String.valueOf((Long) it.next()));
                            matchNumbersGlobal.add(curr);
                            adjacencyMatrix[prev - 1][curr - 1] = 1;
                            matrixIsFilled = true;
                            prev = curr;
                        }
                    } else {
                        matchNumbersGlobal.add(Integer.parseInt(String.valueOf(matchNumbersOrdered.get(0))));
                        singleMatchesGlobal.add(matchNumbersOrdered.get(0));
                    }
                }
                // set previous speaker name
                prevSpeakerName = currSpeakerName;
            }
        }
    }
}