Java AnnotationFS.setFeatureValue方法代码示例

import org.apache.uima.cas.text.AnnotationFS; //导入方法依赖的package包/类
@Override
protected void fillAnnotation(T label, AnnotationFS annotationFS) {
  List<Span> cueTerms = label.getCueTerms();
  ArrayFS fsArray = cas.createArrayFS(cueTerms.size());
  for (int i = 0; i < cueTerms.size(); i++) {
    Span cueTerm = cueTerms.get(i);

    AnnotationFS cueAnnotation = cas.createAnnotation(cueType, cueTerm.getStartIndex(),
        cueTerm.getEndIndex());

    cas.addFsToIndexes(cueAnnotation);
    fsArray.set(i, cueAnnotation);
  }
  cas.addFsToIndexes(fsArray);
  annotationFS.setFeatureValue(cues, fsArray);
}
 

import org.apache.uima.cas.text.AnnotationFS; //导入方法依赖的package包/类
@Override
public void makeAnnotation(AnnotationFS firstToken, AnnotationFS lastToken, String tag) {
    Preconditions.checkArgument(firstToken != null, "firstToken == null");
    CAS cas = firstToken.getCAS();
    Type targetType = tag2TypeMap.get(tag);
    if (targetType == null) {
        logger.warn(String.format("Dictionary tag '%s' is not mapped to any annotation type", tag));
    } else {
        AnnotationFS anno = cas.createAnnotation(targetType, firstToken.getBegin(), lastToken.getEnd());
        Feature firstTokenFeature = targetType.getFeatureByBaseName("firstToken");
        // TODO doc
        if (firstTokenFeature != null) {
            anno.setFeatureValue(firstTokenFeature, firstToken);
        }
        cas.addFsToIndexes(anno);
    }
}
 

import org.apache.uima.cas.text.AnnotationFS; //导入方法依赖的package包/类
/**
 * The individual link annotations are stored in a {@link TreeMap} (chainAnnosPerTye) with chain
 * number and link number references, sorted in an ascending order <br>
 * Iterate over each chain number and link number references and construct the chain.
 */
private void addChainAnnotations(JCas aJCas)
{
    for (Type linkType : chainAnnosPerTyep.keySet()) {
        for (int chainNo : chainAnnosPerTyep.get(linkType).keySet()) {

            Type chainType = aJCas.getCas().getTypeSystem().getType(
                    linkType.getName().substring(0, linkType.getName().length() - 4) + CHAIN);
            Feature firstF = chainType.getFeatureByBaseName(FIRST);
            Feature nextF = linkType.getFeatureByBaseName(NEXT);
            FeatureStructure chain = aJCas.getCas().createFS(chainType);

            aJCas.addFsToIndexes(chain);
            AnnotationFS firstFs = chainAnnosPerTyep.get(linkType).get(chainNo).get(1);
            AnnotationFS linkFs = firstFs;
            chain.setFeatureValue(firstF, firstFs);
            for (int i = 2; i <= chainAnnosPerTyep.get(linkType).get(chainNo).size(); i++) {
                linkFs.setFeatureValue(nextF,
                        chainAnnosPerTyep.get(linkType).get(chainNo).get(i));
                linkFs = chainAnnosPerTyep.get(linkType).get(chainNo).get(i);
            }
        }
    }
}
 

import org.apache.uima.cas.text.AnnotationFS; //导入方法依赖的package包/类
public static void copyRelationAnnotation(AnnotationFS aOldFs, AnnotationFS asourceFS,
        AnnotationFS aTargetFs, JCas aJCas)
{
    Feature[] features = getAllFeatures(aOldFs);
    Type type = aOldFs.getType();
    Feature sourceFeat = type.getFeatureByBaseName(WebAnnoConst.FEAT_REL_SOURCE);
    Feature targetFeat = type.getFeatureByBaseName(WebAnnoConst.FEAT_REL_TARGET);
    AnnotationFS newFs = aJCas.getCas().createAnnotation(type, aOldFs.getBegin(),
            aOldFs.getEnd());
    for (Feature f : features) {
        if (isLinkOrBasicFeatures(aOldFs, f)) {
            continue;
        }
        if (f.equals(sourceFeat)) {
            newFs.setFeatureValue(f, asourceFS);
        }
        else if (f.equals(targetFeat)) {
            newFs.setFeatureValue(f, aTargetFs);
        }
        else {
            setFeatureValue(newFs, f, getFeatureValue(aOldFs, f));
        }
    }
    aJCas.addFsToIndexes(newFs);
}
 

import org.apache.uima.cas.text.AnnotationFS; //导入方法依赖的package包/类
@Override
protected void fillAnnotation(DictionaryTerm label, AnnotationFS annotationFS) {
  List<DictionaryConcept> concepts = label.getConcepts();
  int size = concepts.size();
  ArrayFS arrayFS = cas.createArrayFS(size);
  for (int i = 0; i < size; i++) {
    DictionaryConcept dictionaryConcept = concepts.get(i);
    AnnotationFS conceptAnnotation = dictionaryConceptLabelAdapter.labelToAnnotation(dictionaryConcept);
    arrayFS.set(i, conceptAnnotation);
  }
  cas.addFsToIndexes(arrayFS);
  annotationFS.setFeatureValue(conceptsFeature, arrayFS);
}
 

import org.apache.uima.cas.text.AnnotationFS; //导入方法依赖的package包/类
@Override
public void makeAnnotation(AnnotationFS firstToken, AnnotationFS lastToken, String tag) {
    Preconditions.checkArgument(firstToken != null, "firstToken == null");
    CAS cas = firstToken.getCAS();
    AnnotationFS anno = cas.createAnnotation(resultAnnotationType, firstToken.getBegin(), lastToken.getEnd());
    anno.setStringValue(tagFeature, tag);
    if (firstTokenFeature != null) {
        anno.setFeatureValue(firstTokenFeature, firstToken);
    }
    cas.addFsToIndexes(anno);
}
 

import org.apache.uima.cas.text.AnnotationFS; //导入方法依赖的package包/类
@Override
public void makeAnnotation(AnnotationFS firstToken, AnnotationFS lastToken, Object metadata) {
    Preconditions.checkArgument(firstToken != null, "firstToken == null");
    CAS cas = firstToken.getCAS();
    AnnotationFS resAnno = cas.createAnnotation(resultAnnoType, firstToken.getBegin(), lastToken.getEnd());
    if (firstTokenFeature != null) {
        resAnno.setFeatureValue(firstTokenFeature, firstToken);
    }
    cas.addFsToIndexes(resAnno);
}
 

import org.apache.uima.cas.text.AnnotationFS; //导入方法依赖的package包/类
private <BT extends BratType, BA extends BratStructureAnnotation<BT>> AnnotationFS mapStructureRoles(
        BA bAnno, BratUimaStructureMapping<BT> strMapping) {
    AnnotationFS result = cas.createAnnotation(strMapping.uimaType, 0, 0);
    for (Feature roleFeature : strMapping.featureRoles.keySet()) {
        String roleName = strMapping.featureRoles.get(roleFeature);
        Collection<BratAnnotation<?>> roleBratAnnos = bAnno.getRoleAnnotations().get(roleName);
        if (roleBratAnnos.isEmpty()) {
            continue;
        }
        List<AnnotationFS> roleUimaAnnos = Lists.newLinkedList();
        for (BratAnnotation<?> roleBratAnno : roleBratAnnos) {
            AnnotationFS roleUimaAnno = mappingCtx.getMapped(roleBratAnno);
            if (roleUimaAnno == null) {
                throw new IllegalStateException(String.format(
                        "Brat annotation %s has not been mapped", roleBratAnno));
            }
            roleUimaAnnos.add(roleUimaAnno);
        }
        FeatureStructure featVal;
        if (PUtils.hasCollectionRange(roleFeature)) {
            featVal = PUtils.toCompatibleCollection(cas, roleFeature, roleUimaAnnos);
        } else {
            if (roleUimaAnnos.size() > 1) {
                getLogger().error(String.format(
                        "Too much role '%s' values in anno %s in doc %s. " +
                                "Only the first value will be mapped.",
                        roleName, bAnno.getId(), currentDocName));
            }
            featVal = roleUimaAnnos.get(0);
        }
        result.setFeatureValue(roleFeature, featVal);
    }
    return result;
}
 

import org.apache.uima.cas.text.AnnotationFS; //导入方法依赖的package包/类
/**
 * update a base annotation with slot annotations
 * 
 * @param linkFSesPerAnno
 *            contains list of slot annotations per a base annotation
 * @param aLinkeF
 *            The link slot annotation feature
 */
private void addSlotAnnotations(Map<AnnotationFS, List<FeatureStructure>> linkFSesPerAnno,
        Feature aLinkeF)
{
    for (AnnotationFS anno : linkFSesPerAnno.keySet()) {
        ArrayFS array = anno.getCAS().createArrayFS(linkFSesPerAnno.get(anno).size());
        array.copyFromArray(
                linkFSesPerAnno.get(anno)
                        .toArray(new FeatureStructure[linkFSesPerAnno.get(anno).size()]),
                0, 0, linkFSesPerAnno.get(anno).size());
        anno.setFeatureValue(aLinkeF, array);
        anno.getCAS().addFsToIndexes(anno);
    }
}
 

import org.apache.uima.cas.text.AnnotationFS; //导入方法依赖的package包/类
private static AnnotationFS makeLinkHostFS(JCas aJCas, String aType, int aBegin, int aEnd,
        FeatureStructure... aLinks)
{
    Type hostType = aJCas.getTypeSystem().getType(aType);
    AnnotationFS hostA1 = aJCas.getCas().createAnnotation(hostType, aBegin, aEnd);
    hostA1.setFeatureValue(hostType.getFeatureByBaseName("links"),
            FSCollectionFactory.createFSArray(aJCas, asList(aLinks)));
    aJCas.getCas().addFsToIndexes(hostA1);
    return hostA1;
}
 

import org.apache.uima.cas.text.AnnotationFS; //导入方法依赖的package包/类
@Test
public void testFail()
    throws Exception
{
    TypeSystemDescription tsd = UIMAFramework.getResourceSpecifierFactory()
            .createTypeSystemDescription();
    
    String refTypeName = "RefType";
    
    TypeDescription refTypeDesc = tsd.addType(refTypeName, null, CAS.TYPE_NAME_ANNOTATION);
    refTypeDesc.addFeature("ref", null, CAS.TYPE_NAME_ANNOTATION);
    
    CAS cas = CasCreationUtils.createCas(tsd, null, null);
    
    Type refType = cas.getTypeSystem().getType(refTypeName);
    
    // A regular index annotation
    AnnotationFS anno1 = cas.createAnnotation(cas.getAnnotationType(), 0, 1);
    cas.addFsToIndexes(anno1);

    // A non-index annotation but reachable through an indexe one (below)
    AnnotationFS anno2 = cas.createAnnotation(cas.getAnnotationType(), 0, 1);

    // An indexed annotation that references the non-indexed annotation above
    AnnotationFS anno3 = cas.createAnnotation(refType, 0, 1);
    anno3.setFeatureValue(refType.getFeatureByBaseName("ref"), anno2);
    cas.addFsToIndexes(anno3);
    
    List<LogMessage> messages = new ArrayList<>();
    CasDoctor cd = new CasDoctor(AllFeatureStructuresIndexedCheck.class);
    // A project is not required for this check
    boolean result = cd.analyze(null, cas, messages);
    
    messages.forEach(System.out::println);
    
    assertFalse(result);
}
 

import org.apache.uima.cas.text.AnnotationFS; //导入方法依赖的package包/类
@Test
public void testOK()
    throws Exception
{
    TypeSystemDescription tsd = UIMAFramework.getResourceSpecifierFactory()
            .createTypeSystemDescription();
    
    String refTypeName = "RefType";
    
    TypeDescription refTypeDesc = tsd.addType(refTypeName, null, CAS.TYPE_NAME_ANNOTATION);
    refTypeDesc.addFeature("ref", null, CAS.TYPE_NAME_ANNOTATION);
    
    CAS cas = CasCreationUtils.createCas(tsd, null, null);
    
    Type refType = cas.getTypeSystem().getType(refTypeName);
    
    // A regular index annotation
    AnnotationFS anno1 = cas.createAnnotation(cas.getAnnotationType(), 0, 1);
    cas.addFsToIndexes(anno1);

    // An indexed annotation but reachable through an indexe one (below)
    AnnotationFS anno2 = cas.createAnnotation(cas.getAnnotationType(), 0, 1);
    cas.addFsToIndexes(anno2);

    // An indexed annotation that references the non-indexed annotation above
    AnnotationFS anno3 = cas.createAnnotation(refType, 0, 1);
    anno3.setFeatureValue(refType.getFeatureByBaseName("ref"), anno2);
    cas.addFsToIndexes(anno3);
    
    List<LogMessage> messages = new ArrayList<>();
    CasDoctor cd = new CasDoctor(AllFeatureStructuresIndexedCheck.class);
    // A project is not required for this check
    boolean result = cd.analyze(null, cas, messages);
    
    messages.forEach(System.out::println);
    
    assertTrue(result);
}
 

import org.apache.uima.cas.text.AnnotationFS; //导入方法依赖的package包/类
public static void makeLinkHostFS(JCas aJCas, int aBegin, int aEnd, FeatureStructure... aLinks)
{
    Type hostType = aJCas.getTypeSystem().getType(HOST_TYPE);
    AnnotationFS hostA1 = aJCas.getCas().createAnnotation(hostType, aBegin, aEnd);
    hostA1.setFeatureValue(hostType.getFeatureByBaseName("links"),
            FSCollectionFactory.createFSArray(aJCas, asList(aLinks)));
    aJCas.getCas().addFsToIndexes(hostA1);
}
 

import org.apache.uima.cas.text.AnnotationFS; //导入方法依赖的package包/类
public static AnnotationFS makeLinkHostMultiSPanFeatureFS(JCas aJCas, int aBegin, int aEnd,
        Feature aSpanFeature, String aValue, FeatureStructure... aLinks)
{
    Type hostType = aJCas.getTypeSystem().getType(HOST_TYPE);
    AnnotationFS hostA1 = aJCas.getCas().createAnnotation(hostType, aBegin, aEnd);
    hostA1.setFeatureValue(hostType.getFeatureByBaseName("links"),
            FSCollectionFactory.createFSArray(aJCas, asList(aLinks)));
    hostA1.setStringValue(aSpanFeature, aValue);
    aJCas.getCas().addFsToIndexes(hostA1);
    return hostA1;
}
 

import org.apache.uima.cas.text.AnnotationFS; //导入方法依赖的package包/类
/**
 * Creates a relation layer. For every token, store the governor positions and the dependent
 * annotation
 */

private void createRelationLayer(JCas aJcas, Map<Type, Type> relationayers,
        Map<Type, Map<String, List<AnnotationFS>>> tokenAnnotations,
        Map<Type, Map<String, List<String>>> relationTargets)
{

    for (Type layer : relationayers.keySet()) {

        if (relationTargets.get(layer) == null) {
            continue;
        }
        Feature dependentFeature = layer.getFeatureByBaseName("Dependent");
        Feature governorFeature = layer.getFeatureByBaseName("Governor");

        Map<String, List<String>> tokenIdMaps = relationTargets.get(layer);
        Map<String, List<AnnotationFS>> tokenAnnos = tokenAnnotations
                .get(relationayers.get(layer));
        Map<String, List<AnnotationFS>> relationAnnos = tokenAnnotations.get(layer);
        for (String dependnetId : tokenIdMaps.keySet()) {
            int i = 0;
            for (String governorId : tokenIdMaps.get(dependnetId)) {

                AnnotationFS relationAnno = relationAnnos.get(dependnetId).get(i);
                AnnotationFS dependentAnno = tokenAnnos.get(dependnetId).get(0);
                AnnotationFS governorAnno = tokenAnnos.get(governorId).get(0);

                if (layer.getName().equals(Dependency.class.getName())) {
                    Type tokenType = getType(aJcas.getCas(), Token.class.getName());
                    Feature attachFeature = tokenType.getFeatureByBaseName("pos");
                    AnnotationFS posDependentAnno = dependentAnno;
                    dependentAnno = CasUtil.selectCovered(aJcas.getCas(), tokenType,
                            dependentAnno.getBegin(), dependentAnno.getEnd()).get(0);
                    dependentAnno.setFeatureValue(attachFeature, posDependentAnno);

                    AnnotationFS posGovernorAnno = governorAnno;
                    governorAnno = CasUtil.selectCovered(aJcas.getCas(), tokenType,
                            governorAnno.getBegin(), governorAnno.getEnd()).get(0);
                    governorAnno.setFeatureValue(attachFeature, posGovernorAnno);
                }
                // update begin/end of relation annotation
                if (dependentAnno.getEnd() <= governorAnno.getEnd()) {
                    ((Annotation) relationAnno).setBegin(dependentAnno.getBegin());
                    ((Annotation) relationAnno).setEnd(governorAnno.getEnd());
                }
                else {
                    ((Annotation) relationAnno).setBegin(governorAnno.getBegin());
                    ((Annotation) relationAnno).setEnd(dependentAnno.getEnd());
                }

                relationAnno.setFeatureValue(dependentFeature, dependentAnno);
                relationAnno.setFeatureValue(governorFeature, governorAnno);
                i++;
            }

        }
    }
}