Java AnnotationFS.getBegin方法代码示例

import org.apache.uima.cas.text.AnnotationFS; //导入方法依赖的package包/类
@Override
public DictionaryTerm annotationToLabel(AnnotationFS annotationFS) {
  FeatureStructure conceptsFeatureValue = annotationFS.getFeatureValue(conceptsFeature);
  if (!(conceptsFeatureValue instanceof ArrayFS)) {
    throw new IllegalStateException("Concepts feature structure is not array.");
  }

  ArrayFS conceptsArray = (ArrayFS) conceptsFeatureValue;

  int size = conceptsArray.size();

  List<DictionaryConcept> concepts = new ArrayList<>(size);

  for (int i = 0; i < size; i++) {
    AnnotationFS conceptFeatureStructure = (AnnotationFS) conceptsArray.get(i);
    concepts.add(dictionaryConceptLabelAdapter.annotationToLabel(conceptFeatureStructure));
  }
  return new DictionaryTerm(annotationFS.getBegin(), annotationFS.getEnd(), concepts);
}
 

import org.apache.uima.cas.text.AnnotationFS; //导入方法依赖的package包/类
@Override
public T annotationToLabel(AnnotationFS annotationFS) {
  FeatureStructure cuesValue = annotationFS.getFeatureValue(cues);
  if (!(cuesValue instanceof ArrayFS)) {
    throw new IllegalStateException("Cues is not ArrayFS");
  }
  ArrayFS cuesArray = (ArrayFS) cuesValue;

  int size = cuesArray.size();
  List<Span> cueTerms = new ArrayList<>(size);
  for (int i = 0; i < size; i++) {
    FeatureStructure cueFs = cuesArray.get(i);
    if (!(cueFs instanceof AnnotationFS)) {
      throw new IllegalStateException();
    }
    AnnotationFS cueAnnotation = (AnnotationFS) cueFs;
    Span span = new Span(cueAnnotation.getBegin(),
        cueAnnotation.getEnd());
    cueTerms.add(span);
  }

  return create(annotationFS.getBegin(), annotationFS.getEnd(), cueTerms);
}
 

import org.apache.uima.cas.text.AnnotationFS; //导入方法依赖的package包/类
public Serializable getSpan(JCas aJCas, int aBegin, int aEnd, AnnotationFeature aFeature,
        String aLabelValue)
{
    List<Token> tokens = selectOverlapping(aJCas, Token.class, aBegin, aEnd);
    int begin = tokens.get(0).getBegin();
    int end = tokens.get(tokens.size() - 1).getEnd();
    String baseName = StringUtils.substringBeforeLast(getAnnotationTypeName(), CHAIN) + LINK;
    Type linkType = CasUtil.getType(aJCas.getCas(), baseName);
    
    for (AnnotationFS fs : CasUtil.selectCovered(aJCas.getCas(), linkType, begin, end)) {
        if (fs.getBegin() == aBegin && fs.getEnd() == aEnd) {
            return getFeatureValue(aFeature, fs);
        }
    }
    return null;
}
 

import org.apache.uima.cas.text.AnnotationFS; //导入方法依赖的package包/类
private void mapEvent(UimaBratEventMapping evMapping, AnnotationFS uEvent) {
    if (context.isMapped(uEvent)) {
        return;
    }
    BratEventType bType = evMapping.bratType;
    // use UIMA event annotation boundaries as Brat event trigger boundaries
    BratEventTrigger trigger = new BratEventTrigger(bType,
            uEvent.getBegin(), uEvent.getEnd(), uEvent.getCoveredText());
    // assign id to trigger
    trigger = bac.register(trigger);
    // fill slots
    Multimap<String, BratAnnotation<?>> roleAnnotations = makeRoleMap(
            uEvent, bType, evMapping.roleFeatures);
    // create
    BratEvent bEvent = new BratEvent(bType, trigger, roleAnnotations);
    // assign id
    bEvent = bac.register(bEvent);
    // map to note
    mapNotes(evMapping, bEvent, uEvent);
    // memorize
    context.mapped(uEvent, bEvent);
}
 

import org.apache.uima.cas.text.AnnotationFS; //导入方法依赖的package包/类
/**
 * Write an annotation to the file.
 *
 * @param generator
 *            the generator
 * @param annotation
 *            the annotation
 * @throws IOException
 *             Signals that an I/O exception has occurred.
 */
private void writeFS(JsonGenerator generator, FeatureStructure annotation) throws IOException {
	generator.writeStartObject();

	Type type = annotation.getType();
	generator.writeStringField("type", type.getName());

	List<Feature> features = type.getFeatures();
	if (annotation instanceof AnnotationFS) {
		AnnotationFS annotationFS = (AnnotationFS) annotation;
		if (!(annotationFS.getEnd() == 0 && annotationFS.getBegin() == 0)) {
			generator.writeStringField("coveredText", annotationFS.getCoveredText());
		}
	}

	if (!features.isEmpty()) {
		writeFS(generator, annotation, features);
	}
	generator.writeEndObject();
}
 

import org.apache.uima.cas.text.AnnotationFS; //导入方法依赖的package包/类
/**
 * Extract offset information from the current request. These are either offsets of an existing
 * selected annotations or offsets contained in the request for the creation of a new
 * annotation.
 */
private Offsets getOffsetsFromRequest(IRequestParameters request, JCas jCas, VID aVid)
    throws  IOException
{
    if (aVid.isNotSet() || aVid.isSynthetic()) {
        // Create new span annotation - in this case we get the offset information from the
        // request
        String offsets = request.getParameterValue(PARAM_OFFSETS).toString();
        OffsetsList offsetLists = JSONUtil.getJsonConverter().getObjectMapper()
                .readValue(offsets, OffsetsList.class);

        int annotationBegin = getModelObject().getWindowBeginOffset()
                + offsetLists.get(0).getBegin();
        int annotationEnd = getModelObject().getWindowBeginOffset()
                + offsetLists.get(offsetLists.size() - 1).getEnd();
        return new Offsets(annotationBegin, annotationEnd);
    }
    else {
        // Edit existing span annotation - in this case we look up the offsets in the CAS
        // Let's not trust the client in this case.
        AnnotationFS fs = WebAnnoCasUtil.selectByAddr(jCas, aVid.getId());
        return new Offsets(fs.getBegin(), fs.getEnd());
    }
}
 

import org.apache.uima.cas.text.AnnotationFS; //导入方法依赖的package包/类
private static int getDistance(AnnotationFS annotation1, AnnotationFS annotation2) {
  if (annotation1.getEnd() < annotation2.getBegin()) {
    return JCasUtil.selectBetween(Token.class, annotation1, annotation2).size();
  } else if (annotation1.getBegin() > annotation2.getEnd()) {
    return JCasUtil.selectBetween(Token.class, annotation2, annotation1).size();
  } else {
    return 0;
  }
}
 

import org.apache.uima.cas.text.AnnotationFS; //导入方法依赖的package包/类
@Override
public DictionaryConcept annotationToLabel(AnnotationFS annotationFS) {
  return new DictionaryConcept(
      annotationFS.getBegin(),
      annotationFS.getEnd(),
      annotationFS.getStringValue(identifierFeature),
      annotationFS.getStringValue(sourceFeature),
      annotationFS.getStringValue(semanticTypeFeature),
      annotationFS.getDoubleValue(confidenceFeature)
  );
}
 

import org.apache.uima.cas.text.AnnotationFS; //导入方法依赖的package包/类
private void divideAnnotation(AnnotationFS annotation) {
  Objects.requireNonNull(typeToCreate);
  Objects.requireNonNull(dividers);

  FSIterator<AnnotationFS> subiterator = dividers.subiterator(annotation);
  int begin = annotation.getBegin();
  while (subiterator.hasNext()) {
    int end = subiterator.next().getBegin();
    cas.addFsToIndexes(cas.createAnnotation(typeToCreate, begin, end));
    begin = end;
  }
}
 

import org.apache.uima.cas.text.AnnotationFS; //导入方法依赖的package包/类
public static String matchSequence(AutomatonEngine a, String str) {
	final List<RegexOccurrence> episodes = Lists.newLinkedList();
	RecognitionHandler rh = new  RecognitionHandler() {
		@Override
		public void recognizedEpisode(RegexOccurrence episode) {
			episodes.add(episode);
		}
	};
	a.addRecognitionHandler(rh);
	StringTokenizer st = new StringTokenizer(str, " ");
	int i = 0;
	while(st.hasMoreTokens()) {
		String s = st.nextToken();
		Annotation anno = Mockito.mock(Annotation.class);
		Mockito.when(anno.getCoveredText()).thenReturn(s);
		Mockito.when(anno.getBegin()).thenReturn(i);
		Mockito.when(anno.getEnd()).thenReturn(i+1);
		a.nextAnnotation(anno, true);
		i += 1;
	}
	a.finish();
	List<String> results = Lists.newLinkedList();
	for(RegexOccurrence e:episodes) {
		String result = Joiner.on(' ').join(e.getLabels());
		AnnotationFS first;
		AnnotationFS last;
		if(e.size() > 0) {
			first = e.getLabelledAnnotations().get(0).getAnnotation();
			last = e.getLabelledAnnotations().get(e.size()-1).getAnnotation();
			result += " (" + first.getBegin() + "," + last.getEnd() + ")";
		} else {
			result += " (none)";
		}
			
		results.add(result);
	}
	return Joiner.on(" | ").join(results);
}
 

import org.apache.uima.cas.text.AnnotationFS; //导入方法依赖的package包/类
@Override
public Position getPosition(int aCasId, FeatureStructure aFS, String aFeature, String aRole,
        int aLinkTargetBegin, int aLinkTargetEnd, LinkCompareBehavior aLinkCompareBehavior)
{
    Type type = aFS.getType();
    AnnotationFS sourceFS = (AnnotationFS) aFS.getFeatureValue(type
            .getFeatureByBaseName(sourceFeature));
    AnnotationFS targetFS = (AnnotationFS) aFS.getFeatureValue(type
            .getFeatureByBaseName(targetFeature));
    
    String collectionId = null;
    String documentId = null;
    try {
        DocumentMetaData dmd = DocumentMetaData.get(aFS.getCAS());
        collectionId = dmd.getCollectionId();
        documentId = dmd.getDocumentId();
    }
    catch (IllegalArgumentException e) {
        // We use this information only for debugging - so we can ignore if the information
        // is missing.
    }
    
    String linkTargetText = null;
    if (aLinkTargetBegin != -1 && aFS.getCAS().getDocumentText() != null) {
        linkTargetText = aFS.getCAS().getDocumentText()
                .substring(aLinkTargetBegin, aLinkTargetEnd);
    }
    
    return new ArcPosition(collectionId, documentId, aCasId, getType(), 
            sourceFS != null ? sourceFS.getBegin() : -1,
            sourceFS != null ? sourceFS.getEnd() : -1,
            sourceFS != null ? sourceFS.getCoveredText() : null,
            targetFS != null ? targetFS.getBegin() : -1,
            targetFS != null ? targetFS.getEnd() : -1,
            targetFS != null ? targetFS.getCoveredText() : null,
            aFeature, aRole, aLinkTargetBegin, aLinkTargetEnd, linkTargetText,
            aLinkCompareBehavior);
}
 

import org.apache.uima.cas.text.AnnotationFS; //导入方法依赖的package包/类
@Override
public int compare(AnnotationFS arg0, AnnotationFS arg1)
{
    int beginDiff = arg0.getBegin() - arg1.getBegin();
    if (beginDiff == 0) {
        return arg1.getEnd() - arg0.getEnd();
    }
    else {
        return beginDiff;
    }
}
 

import org.apache.uima.cas.text.AnnotationFS; //导入方法依赖的package包/类
private void onMatch(AnnotationFS gold, AnnotationFS sys) {
    OverlapHelper.evaluateOverlap(gold, sys, measures);
    if (gold.getBegin() == sys.getBegin() && gold.getEnd() == sys.getEnd()) {
        exactMatchingCounter++;
    } else {
        partialMatchingCounter++;
    }
}
 

import org.apache.uima.cas.text.AnnotationFS; //导入方法依赖的package包/类
private void mapEntity(UimaBratEntityMapping entMapping, AnnotationFS uEntity) {
    if (context.isMapped(uEntity)) {
        return;
    }
    BratEntityType bType = entMapping.bratType;
    // create brat annotation instance
    BratEntity bEntity = new BratEntity(bType,
            uEntity.getBegin(), uEntity.getEnd(), uEntity.getCoveredText());
    // add to container - it assigns ID
    bEntity = bac.register(bEntity);
    // map to note
    mapNotes(entMapping, bEntity, uEntity);
    // memorize
    context.mapped(uEntity, bEntity);
}
 

import org.apache.uima.cas.text.AnnotationFS; //导入方法依赖的package包/类
private boolean isMultiToken(AnnotationFS aFs)
{

    for (AnnotationUnit unit : units) {
        if (unit.begin <= aFs.getBegin() && unit.end > aFs.getBegin()
                && unit.end < aFs.getEnd()) {
            return true;
        }
    }
    return false;
}