Java Code Examples for org.apache.uima.jcas.tcas.Annotation#removeFromIndexes()

/**
 * Remove an annotation to the JCas index, notifying UimaMonitor of the fact we have done so.
 *
 * <p>Relations that refer to the given annotation will also be removed.
 *
 * @param annotations Annotation(s) to remove
 */
public void remove(Collection<? extends Annotation> annotations) {
  for (Annotation annot : annotations) {

    if (annot instanceof Recordable) {
      try {
        addToHistory(
            annot.getCAS().getJCas(), HistoryEvents.createAdded((Recordable) annot, referrer));
      } catch (CASException e) {
        monitor.error("Unable to add to history on remove", e);
      }
    }

    if (annot instanceof Entity) {
      for (Relation r : getRelations((Entity) annot)) {
        monitor.entityRemoved(r.getType().getName());
        r.removeFromIndexes();
      }
    }

    monitor.entityRemoved(annot.getType().getName());

    annot.removeFromIndexes();
  }
}
 

@Override
public void process(JCas jCas) throws AnalysisEngineProcessException {

	for (Token t : select(jCas, Token.class)) {

		// filter by POS
		String pos = t.getPos();
		if (pos == null)
			pos = "UNKNOWN";
		if (SKIP_POS.contains(pos)) {
			for (Annotation a : selectCovered(jCas, Annotation.class,
			        t.getBegin(), t.getEnd())) {
				if (BlueCasUtil.haveSameBeginEnd(t, a)
				        && BIO_ANNOTATIONS.contains(a.getClass()))
					a.removeFromIndexes(jCas);
			}
		}
	}
}
 

/**
 * Remove unlikely annotation.
 *
 * @param annotations
 *            removal candidates
 */
private void cleanAnnotation(Collection<? extends Annotation> annotations) {
	for (Annotation a : annotations) {
		// less than two letters
		String ne = a.getCoveredText();
		if (ne.replaceAll("[^\\p{L}]", "").length() < 2) {
			log.log(Level.FINEST, "Removing Named Entity: " + ne);
			a.removeFromIndexes();
		}
	}
}
 

@Override
public void process(JCas jCas) throws AnalysisEngineProcessException {

    // Copy the tokens into a new collection to avoid
    // ConcurrentModificationExceptions
    if (className.equals("all")) {
        for (TOP t : newArrayList(select(jCas, TOP.class)))
            t.removeFromIndexes();
    } else {
        for (Annotation a : newArrayList(select(jCas, aClass)))
            a.removeFromIndexes();
    }
}
 

@Override
public void process(JCas jCas) throws AnalysisEngineProcessException {

    boolean hasRodent = false;

    for (LinnaeusSpecies sp : select(jCas, LinnaeusSpecies.class)) {
        // e.g. species:ncbi:9685
        int species = parseInt(sp.getMostProbableSpeciesId().substring(
                "species:ncbi:".length()));
        if (NCBI_MURIDAE.contains(species)) {
            hasRodent = true;
            break;
        }
    }

    if (!hasRodent) {
        // Copy the tokens into a new collection to avoid
        // ConcurrentModificationExceptions
        if (className.equals("all")) {
            for (TOP t : newArrayList(select(jCas, TOP.class)))
                t.removeFromIndexes();
        } else {
            for (Annotation a : newArrayList(select(jCas, aClass)))
                a.removeFromIndexes();
        }
    }
}
 

@SuppressWarnings("unchecked")
@Override
public void process(JCas jCas) throws AnalysisEngineProcessException {

    //First, one use java reflection to check the existence of the given
    //annotation's classes.
    Class<? extends Annotation> protectedAnnotationClass;
    List<Class<? extends Annotation>> filteredAnnotationClasses = new LinkedList<Class<? extends Annotation>>();

    try {

        protectedAnnotationClass = (Class<? extends Annotation>) Class
                .forName(protectedAnnotationClassName);
        for (String filteredAnnotationClassName : filteredAnnotationsClassNames) {
            filteredAnnotationClasses
                    .add((Class<? extends Annotation>) Class
                            .forName(filteredAnnotationClassName));
        }

    } catch (ClassNotFoundException e) {
        throw new AnalysisEngineProcessException(e);
    }

    //Then, one simply go through all pairs of the existing annotations
    //verifying if they overlap (distance = -1)
    List<Annotation> toDelete = new LinkedList<Annotation>();
    for (Annotation protectedOccurrence : select(jCas,
            protectedAnnotationClass)) {

        for (Class<? extends Annotation> filteredAnnotationClass : filteredAnnotationClasses) {
            for (Annotation filteredAnnotOccurrence : select(jCas,
                    filteredAnnotationClass)) {
                boolean overlap = BlueCasUtil.distance(protectedOccurrence,
                        filteredAnnotOccurrence) == -1;
                if (overlap) {
                    toDelete.add(protectedOccurrence);
                }
            }
        }

    }

    for (Annotation annot : toDelete) {
        annot.removeFromIndexes();
    }
}