use of org.apache.uima.cas.FeatureStructure in project webanno by webanno.
the class ImportExportServiceImpl method updateCasWithTagSet.
/**
* A Helper method to add {@link TagsetDescription} to {@link CAS}
*
* @param aCas
* the CAA.
* @param aLayer
* the layer.
* @param aTagSetName
* the tagset.
*/
private static void updateCasWithTagSet(CAS aCas, String aLayer, String aTagSetName) {
Type TagsetType = CasUtil.getType(aCas, TagsetDescription.class);
Feature layerFeature = TagsetType.getFeatureByBaseName("layer");
Feature nameFeature = TagsetType.getFeatureByBaseName("name");
boolean tagSetModified = false;
// modify existing tagset Name
for (FeatureStructure fs : CasUtil.select(aCas, TagsetType)) {
String layer = fs.getStringValue(layerFeature);
String tagSetName = fs.getStringValue(nameFeature);
if (layer.equals(aLayer)) {
// only if the tagset name is changed
if (!aTagSetName.equals(tagSetName)) {
fs.setStringValue(nameFeature, aTagSetName);
aCas.addFsToIndexes(fs);
}
tagSetModified = true;
break;
}
}
if (!tagSetModified) {
FeatureStructure fs = aCas.createFS(TagsetType);
fs.setStringValue(layerFeature, aLayer);
fs.setStringValue(nameFeature, aTagSetName);
aCas.addFsToIndexes(fs);
}
}
use of org.apache.uima.cas.FeatureStructure in project webanno by webanno.
the class ChainRenderer method render.
@Override
public void render(JCas aJcas, List<AnnotationFeature> aFeatures, VDocument aResponse, AnnotatorState aState) {
List<AnnotationFeature> visibleFeatures = aFeatures.stream().filter(f -> f.isVisible() && f.isEnabled()).collect(Collectors.toList());
// Find the features for the arc and span labels - it is possible that we do not find a
// feature for arc/span labels because they may have been disabled.
AnnotationFeature spanLabelFeature = null;
AnnotationFeature arcLabelFeature = null;
for (AnnotationFeature f : visibleFeatures) {
if (WebAnnoConst.COREFERENCE_TYPE_FEATURE.equals(f.getName())) {
spanLabelFeature = f;
}
if (WebAnnoConst.COREFERENCE_RELATION_FEATURE.equals(f.getName())) {
arcLabelFeature = f;
}
}
// At this point arc and span feature labels must have been found! If not, the later code
// will crash.
ChainAdapter typeAdapter = getTypeAdapter();
Type chainType = typeAdapter.getAnnotationType(aJcas.getCas());
Feature chainFirst = chainType.getFeatureByBaseName(typeAdapter.getChainFirstFeatureName());
int colorIndex = 0;
// Iterate over the chains
for (FeatureStructure chainFs : selectFS(aJcas.getCas(), chainType)) {
AnnotationFS linkFs = (AnnotationFS) chainFs.getFeatureValue(chainFirst);
AnnotationFS prevLinkFs = null;
// Iterate over the links of the chain
while (linkFs != null) {
Feature linkNext = linkFs.getType().getFeatureByBaseName(typeAdapter.getLinkNextFeatureName());
AnnotationFS nextLinkFs = (AnnotationFS) linkFs.getFeatureValue(linkNext);
// Is link after window? If yes, we can skip the rest of the chain
if (linkFs.getBegin() >= aState.getWindowEndOffset()) {
// Go to next chain
break;
}
// end within the window
if (!(linkFs.getBegin() >= aState.getWindowBeginOffset()) && (linkFs.getEnd() <= aState.getWindowEndOffset())) {
// prevLinkFs remains null until we enter the window
linkFs = nextLinkFs;
// Go to next link
continue;
}
String bratTypeName = TypeUtil.getUiTypeName(typeAdapter);
// Render span
{
String bratLabelText = TypeUtil.getUiLabelText(typeAdapter, linkFs, (spanLabelFeature != null) ? asList(spanLabelFeature) : emptyList());
String bratHoverText = TypeUtil.getUiHoverText(typeAdapter, linkFs, (spanLabelFeature != null) ? asList(spanLabelFeature) : emptyList());
VRange offsets = new VRange(linkFs.getBegin() - aState.getWindowBeginOffset(), linkFs.getEnd() - aState.getWindowBeginOffset());
aResponse.add(new VSpan(typeAdapter.getLayer(), linkFs, bratTypeName, offsets, colorIndex, singletonMap("label", bratLabelText), singletonMap("label", bratHoverText)));
}
// and last link are within the window ;)
if (prevLinkFs != null) {
String bratLabelText = null;
if (typeAdapter.isLinkedListBehavior() && arcLabelFeature != null) {
// Render arc label
bratLabelText = TypeUtil.getUiLabelText(typeAdapter, prevLinkFs, asList(arcLabelFeature));
} else {
// Render only chain type
bratLabelText = TypeUtil.getUiLabelText(typeAdapter, prevLinkFs, emptyList());
}
aResponse.add(new VArc(typeAdapter.getLayer(), new VID(prevLinkFs, 1, VID.NONE, VID.NONE), bratTypeName, prevLinkFs, linkFs, colorIndex, singletonMap("label", bratLabelText)));
}
// Render errors if required features are missing
renderRequiredFeatureErrors(visibleFeatures, linkFs, aResponse);
// if (BratAjaxCasUtil.isSame(linkFs, nextLinkFs)) {
// log.error("Loop in CAS detected, aborting rendering of chains");
// break;
// }
prevLinkFs = linkFs;
linkFs = nextLinkFs;
}
// The color index is updated even for chains that have no visible links in the current
// window because we would like the chain color to be independent of visibility. In
// particular the color of a chain should not change when switching pages/scrolling.
colorIndex++;
}
}
use of org.apache.uima.cas.FeatureStructure in project webanno by webanno.
the class RelationRenderer method getRelationLinks.
/**
* Get relation links to display in relation yield
*/
private Map<Integer, Set<Integer>> getRelationLinks(JCas aJcas, int aWindowBegin, int aWindowEnd, Type type, Feature dependentFeature, Feature governorFeature, Feature arcSpanFeature) {
ArcAdapter typeAdapter = getTypeAdapter();
FeatureStructure dependentFs;
FeatureStructure governorFs;
Map<Integer, Set<Integer>> relations = new ConcurrentHashMap<>();
for (AnnotationFS fs : selectCovered(aJcas.getCas(), type, aWindowBegin, aWindowEnd)) {
if (typeAdapter.getAttachFeatureName() != null) {
dependentFs = fs.getFeatureValue(dependentFeature).getFeatureValue(arcSpanFeature);
governorFs = fs.getFeatureValue(governorFeature).getFeatureValue(arcSpanFeature);
} else {
dependentFs = fs.getFeatureValue(dependentFeature);
governorFs = fs.getFeatureValue(governorFeature);
}
if (dependentFs == null || governorFs == null) {
log.warn("Relation [" + typeAdapter.getLayer().getName() + "] with id [" + getAddr(fs) + "] has loose ends - cannot render.");
continue;
}
Set<Integer> links = relations.get(getAddr(governorFs));
if (links == null) {
links = new ConcurrentSkipListSet<>();
}
links.add(getAddr(dependentFs));
relations.put(getAddr(governorFs), links);
}
// Update other subsequent links
for (int i = 0; i < relations.keySet().size(); i++) {
for (Integer fs : relations.keySet()) {
updateLinks(relations, fs);
}
}
// to start displaying the text from the governor, include it
for (Integer fs : relations.keySet()) {
relations.get(fs).add(fs);
}
return relations;
}
use of org.apache.uima.cas.FeatureStructure in project webanno by webanno.
the class SpanRenderer method render.
@Override
public void render(JCas aJcas, List<AnnotationFeature> aFeatures, VDocument aResponse, AnnotatorState aBratAnnotatorModel) {
List<AnnotationFeature> visibleFeatures = aFeatures.stream().filter(f -> f.isVisible() && f.isEnabled()).collect(Collectors.toList());
SpanAdapter typeAdapter = getTypeAdapter();
Type type = getType(aJcas.getCas(), typeAdapter.getAnnotationTypeName());
int windowBegin = aBratAnnotatorModel.getWindowBeginOffset();
int windowEnd = aBratAnnotatorModel.getWindowEndOffset();
List<Sentence> visibleSentences = selectCovered(aJcas, Sentence.class, windowBegin, windowEnd);
for (AnnotationFS fs : selectCovered(aJcas.getCas(), type, windowBegin, windowEnd)) {
String bratTypeName = TypeUtil.getUiTypeName(typeAdapter);
Map<String, String> features = getFeatures(typeAdapter, fs, visibleFeatures);
Map<String, String> hoverFeatures = getHoverFeatures(typeAdapter, fs, aFeatures);
Sentence beginSent = null;
Sentence endSent = null;
// the visible window
for (Sentence sent : visibleSentences) {
if (beginSent == null) {
// offset of the current annotation.
if (sent.getBegin() <= fs.getBegin() && fs.getBegin() <= sent.getEnd()) {
beginSent = sent;
}
// second sentence.
if (fs.getBegin() == fs.getEnd()) {
endSent = sent;
}
}
if (endSent == null) {
if (sent.getBegin() <= fs.getEnd() && fs.getEnd() <= sent.getEnd()) {
endSent = sent;
}
}
if (beginSent != null && endSent != null) {
break;
}
}
if (beginSent == null || endSent == null) {
throw new IllegalStateException("Unable to determine sentences in which the annotation starts/ends: " + fs);
}
List<Sentence> sentences = selectCovered(aJcas, Sentence.class, beginSent.getBegin(), endSent.getEnd());
List<VRange> ranges = new ArrayList<>();
if (sentences.size() > 1) {
for (Sentence sentence : sentences) {
if (sentence.getBegin() <= fs.getBegin() && fs.getBegin() < sentence.getEnd()) {
ranges.add(new VRange(fs.getBegin() - windowBegin, sentence.getEnd() - windowBegin));
} else if (sentence.getBegin() <= fs.getEnd() && fs.getEnd() <= sentence.getEnd()) {
ranges.add(new VRange(sentence.getBegin() - windowBegin, fs.getEnd() - windowBegin));
} else {
ranges.add(new VRange(sentence.getBegin() - windowBegin, sentence.getEnd() - windowBegin));
}
}
aResponse.add(new VSpan(typeAdapter.getLayer(), fs, bratTypeName, ranges, features, hoverFeatures));
} else {
// FIXME It should be possible to remove this case and the if clause because
// the case that a FS is inside a single sentence is just a special case
aResponse.add(new VSpan(typeAdapter.getLayer(), fs, bratTypeName, new VRange(fs.getBegin() - windowBegin, fs.getEnd() - windowBegin), features, hoverFeatures));
}
// Render errors if required features are missing
renderRequiredFeatureErrors(visibleFeatures, fs, aResponse);
// Render slots
int fi = 0;
for (AnnotationFeature feat : typeAdapter.listFeatures()) {
if (MultiValueMode.ARRAY.equals(feat.getMultiValueMode()) && LinkMode.WITH_ROLE.equals(feat.getLinkMode())) {
List<LinkWithRoleModel> links = typeAdapter.getFeatureValue(feat, fs);
for (int li = 0; li < links.size(); li++) {
LinkWithRoleModel link = links.get(li);
FeatureStructure targetFS = selectByAddr(fs.getCAS(), link.targetAddr);
aResponse.add(new VArc(typeAdapter.getLayer(), new VID(fs, fi, li), bratTypeName, fs, targetFS, link.role, features));
}
}
fi++;
}
}
}
use of org.apache.uima.cas.FeatureStructure in project webanno by webanno.
the class ChainAdapter method newChain.
/**
* Create a new chain head feature structure. Already adds the chain to the CAS.
*/
private FeatureStructure newChain(JCas aJCas, AnnotationFS aFirstLink) {
Type chainType = getAnnotationType(aJCas.getCas());
FeatureStructure newChain = aJCas.getCas().createFS(chainType);
newChain.setFeatureValue(chainType.getFeatureByBaseName(chainFirstFeatureName), aFirstLink);
aJCas.addFsToIndexes(newChain);
return newChain;
}
Aggregations