Java JCas类代码示例

import org.apache.uima.jcas.JCas; //导入依赖的package包/类
/**
 * Extracts aspect expressions from a CAS.
 * @param cas the CAS containing {@link AspectTarget} annotations
 * @param res the {@link Result}, where the expressions are added
 */
private void extractAspectExpressions(JCas cas, Result res) {
    String text = cas.getDocumentText();
    int begin = 0;
    int end = text.length()-1;

    boolean aspectActive = false;
    for (AspectTarget t: select(cas, AspectTarget.class)) {
        end = t.getEnd();
        if (aspectActive && t.getAspectTargetType().compareTo("O") == 0) {
            aspectActive = false;
            res.addAspectExpression(new AspectExpression(text.substring(begin, end), begin, end));
        } else if (!aspectActive && t.getAspectTargetType().compareTo("B") == 0) {
            aspectActive = true;
            begin = t.getBegin();
        } else if (aspectActive && t.getAspectTargetType().compareTo("B") == 0) {
            aspectActive = true;
            res.addAspectExpression(new AspectExpression(text.substring(begin, end), begin, end));
            begin = t.getBegin();
        }
    }
    if (aspectActive) {
        res.addAspectExpression(new AspectExpression(text.substring(begin, end), begin, end));
    }
}
 

import org.apache.uima.jcas.JCas; //导入依赖的package包/类
static private IdentifiedAnnotation createSemanticAnnotation( final JCas jcas, final int cTakesSemantic ) {
   switch ( cTakesSemantic ) {
      case NE_TYPE_ID_DRUG: {
         return new MedicationMention( jcas );
      }
      case NE_TYPE_ID_ANATOMICAL_SITE: {
         return new AnatomicalSiteMention( jcas );
      }
      case NE_TYPE_ID_DISORDER: {
         return new DiseaseDisorderMention( jcas );
      }
      case NE_TYPE_ID_FINDING: {
         return new SignSymptomMention( jcas );
      }
      case NE_TYPE_ID_LAB: {
         return new LabMention( jcas );
      }
      case NE_TYPE_ID_PROCEDURE: {
         return new ProcedureMention( jcas );
      }
   }
   return new EntityMention( jcas );
}
 

import org.apache.uima.jcas.JCas; //导入依赖的package包/类
@Override
public void process(JCas jCas) throws AnalysisEngineProcessException {
  try{
    JCas deidView = CasUtil.getView(jCas.getCas(), DEID_VIEW_NAME, true).getJCas();

    String text = jCas.getDocumentText();

    String decoderOut = decoder.decodeString(text);

    while(true) {
      Matcher m = xmlPatt.matcher(decoderOut);
      if (!m.find()) {
        break;
      }
      String matchType = m.group(1);
      int matchStart = m.start();
      int matchEnd = m.end();
      decoderOut = decoderOut.substring(0, matchStart) + "[" + matchType + "]" + decoderOut.substring(matchEnd);
    }

    deidView.setDocumentText(decoderOut);
  }catch(Exception e){
    System.err.println("Error trying to run mist!");
    throw new AnalysisEngineProcessException(e);
  }
}
 

import org.apache.uima.jcas.JCas; //导入依赖的package包/类
public static void main(String[] args) throws Exception {

//        TypeSystemDescription tsd = TypeSystemDescriptionFactory.createTypeSystemDescriptionFromPath("../desc/TypeSystem.xml");
        JCas jcas = JCasFactory.createJCas();
        jcas.setDocumentText("Patient is a 30-year-old man named Leroy Butler from Green Bay, WI.");
        AnalysisEngineDescription aed = AnalysisEngineFactory.createEngineDescription(MistAnalysisEngine.class,
                MistAnalysisEngine.PARAM_MODEL_PATH,
                "SHARP/model/model");
        SimplePipeline.runPipeline(jcas, aed);
        for(Annotation annot : JCasUtil.select(jcas, Annotation.class)){
            System.out.println("Found annotation: " + annot.getCoveredText());
        }
        JCas deidView = jcas.getView(MistAnalysisEngine.DEID_VIEW_NAME);
        System.out.println("Deidentified version:");
        System.out.println(deidView.getDocumentText());
    }
 

import org.apache.uima.jcas.JCas; //导入依赖的package包/类
@Override
   public void process( final JCas jcas ) throws AnalysisEngineProcessException {

      final String patient = Long.toString( SourceMetadataUtil.getPatientNum( jcas ) );
      final SourceData sourceData = SourceMetadataUtil.getSourceData( jcas );
      final String encounter = sourceData==null?"null":sourceData.getSourceEncounterId();
      final String providerId = sourceData==null?"null":SourceMetadataUtil.getProviderId( sourceData );
      // source date not used ???
//      final String sourceDate = sourceData.getSourceOriginalDate();
      JCas deidView = null;
      try{
        deidView = jcas.getView(DEID_VIEW);
      }catch(CASException e){
        throw new AnalysisEngineProcessException(e);
      }
      final Collection<String> conceptLines = createConceptLines( deidView, patient, encounter, providerId );

      final File outputFile = new File( _outputRootDir, encounter );
      saveAnnotations( outputFile, conceptLines );

   }
 

import org.apache.uima.jcas.JCas; //导入依赖的package包/类
static private Collection<String> createConceptLines( final JCas jcas,
                                              final String patient, final String encounter, final String provider ) {
   final Collection<IdentifiedAnnotation> annotations = JCasUtil.select( jcas, IdentifiedAnnotation.class );
   if ( annotations.isEmpty() ) {
      return Collections.emptyList();
   }
   final ConceptLinesBuilder conceptLinesBuilder = new ConceptLinesBuilder();
   conceptLinesBuilder.patient( patient ).encounter( encounter ).provider( provider );
   final Collection<String> annotationDataLines = new ArrayList<>();
   for ( IdentifiedAnnotation annotation : annotations ) {
      conceptLinesBuilder
            .clearAttributes()
            .value( annotation.getCoveredText() )
            .attribute( MODIFIER_CD_BEGIN, annotation.getBegin() )
            .attribute( MODIFIER_CD_END, annotation.getEnd() )
            .attribute( MODIFIER_CD_POLARITY, annotation.getPolarity() < 0 ? NEGATED : AFFIRMED )
            .attribute( MODIFIER_CD_SUBJECT, annotation.getSubject() )
            .attribute( MODIFIER_CD_SECTION, annotation.getSegmentID() )
            .attribute( MODIFIER_CD_UNCERTAINTY, annotation.getUncertainty() )
            .attribute( MODIFIER_CD_BODY_LOCATION, null )
            .attribute( MODIFIER_CD_SEVERITY, null )
            .attribute( MODIFIER_CD_DOC_TIME_REL, getDocTimeRel( annotation ) )
            .attribute( MODIFIER_CD_SENT, getSentenceCoverage(jcas, annotation ) );
      // At this time the codes are all that change
      final Collection<String> codes = OntologyConceptUtil.getCodes( annotation );
      codes.addAll( OntologyConceptUtil.getCuis( annotation ) );
      for ( String code : codes ) {
         conceptLinesBuilder.code( code );
         annotationDataLines.addAll( conceptLinesBuilder.buildLines() );
      }
   }
   return annotationDataLines;
}
 

import org.apache.uima.jcas.JCas; //导入依赖的package包/类
@Override public void process(JCas jCas)
        throws AnalysisEngineProcessException
{
    try (OutputStream docOS = getOutputStream(jCas, ".txt")) {
        Collection<BIOTokenArgumentAnnotation> bioTokenArgumentAnnotations = JCasUtil
                .select(jCas, BIOTokenArgumentAnnotation.class);

        if (bioTokenArgumentAnnotations.isEmpty()) {
            throw new IllegalStateException(
                    "No annotations of type BIOTokenArgumentAnnotation found. Make sure you run ArgumentTokenBIOAnnotator in the pipeline.");
        }

        PrintWriter pw = new PrintWriter(docOS, true);

        for (BIOTokenArgumentAnnotation tokenAnnotation : bioTokenArgumentAnnotations) {
            pw.printf("%s\t%s%n", tokenAnnotation.getCoveredText(), tokenAnnotation.getTag());
        }

        IOUtils.closeQuietly(docOS);
    }
    catch (Exception e) {
        throw new AnalysisEngineProcessException(e);
    }
}
 

import org.apache.uima.jcas.JCas; //导入依赖的package包/类
private static ArgumentComponent createAnnotation(String fullTag, JCas jCas)
{
    String tag = fullTag.split("-")[0];

    switch (tag.toLowerCase()) {
    case "premise":
        return new Premise(jCas);
    case "backing":
        return new Backing(jCas);
    case "claim":
        return new Claim(jCas);
    case "rebuttal":
        return new Rebuttal(jCas);
    case "refutation":
        return new Refutation(jCas);
    default:
        throw new IllegalArgumentException("Unknown annotation type " + tag);
    }
}
 

import org.apache.uima.jcas.JCas; //导入依赖的package包/类
/**
 * Writes "typesystem.xml" to the output tar.gz
 *
 * @param aJCas any jcas from the collection to get the currently active typesystem
 * @throws IOException IO Exception
 */
private void writeTypeSystem(JCas aJCas)
        throws IOException
{
    try {
        String name = "typesystem.xml";
        java.io.ByteArrayOutputStream stream = new java.io.ByteArrayOutputStream();

        TypeSystemUtil.typeSystem2TypeSystemDescription(aJCas.getTypeSystem()).toXML(stream);

        // add to tar
        addSingleEntryToTar(stream.toByteArray(), name);
    }
    catch (SAXException e) {
        throw new IOException(e);
    }
}
 

import org.apache.uima.jcas.JCas; //导入依赖的package包/类
public static SortedMap<String, Sentence> extractSentenceIDsAndContent(
        StandaloneArgument argument)
        throws IOException
{
    JCas jCas = argument.getJCas();
    // extract sentences
    SortedMap<String, Sentence> result = new TreeMap<>();

    ArrayList<Sentence> sentences = new ArrayList<>(JCasUtil.select(jCas, Sentence.class));
    for (int i = 0; i < sentences.size(); i++) {
        Sentence sentence = sentences.get(i);

        // create unique id by combining argument id and sentence position
        String sentenceId = getSentenceID(argument, i);

        result.put(sentenceId, sentence);
    }

    //        System.out.println("extractSentenceIDsAndContent result keys: " + result.keySet());

    return result;
}
 

import org.apache.uima.jcas.JCas; //导入依赖的package包/类
public JCas getJCas()
        throws RuntimeException
{
    if (base64JCas == null) {
        return null;
    }

    try {
        byte[] bytes = new BASE64Decoder()
                .decodeBuffer(new ByteArrayInputStream(base64JCas.getBytes("utf-8")));
        JCas jCas = JCasFactory.createJCas();
        XmiCasDeserializer.deserialize(new ByteArrayInputStream(bytes), jCas.getCas());

        return jCas;
    }
    catch (Exception e) {
        throw new RuntimeException(e);
    }
}
 

import org.apache.uima.jcas.JCas; //导入依赖的package包/类
private static void copyParagraphAndTokenAnnotations(JCas source, JCas target)
{
    if (!source.getDocumentText().equals(target.getDocumentText())) {
        throw new IllegalArgumentException("Source and target have different content");
    }

    for (Paragraph p : JCasUtil.select(source, Paragraph.class)) {
        Paragraph paragraph = new Paragraph(target);
        paragraph.setBegin(p.getBegin());
        paragraph.setEnd(p.getEnd());
        paragraph.addToIndexes();
    }

    for (Token t : JCasUtil.select(source, Token.class)) {
        Token token = new Token(target);
        token.setBegin(t.getBegin());
        token.setEnd(t.getEnd());
        token.addToIndexes();
    }
}
 

import org.apache.uima.jcas.JCas; //导入依赖的package包/类
@Override
boolean keepArgument(JCas jCas)
{
    Collection<Token> tokens = JCasUtil.select(jCas, Token.class);

    int oovWords = 0;

    for (Token token : tokens) {
        if (!vocabulary.contains(token.getCoveredText())) {
            oovWords++;
        }
    }

    frequency.addValue(oovWords);
    //        System.out.println(frequency);

    return oovWords <= THRESHOLD;
}
 

import org.apache.uima.jcas.JCas; //导入依赖的package包/类
@Override
public boolean keepArgument(Argument argument, Debate parentDebate)
        throws IOException
{
    if (!(argument instanceof StandaloneArgument)) {
        throw new IllegalStateException(
                StandaloneArgument.class.getName() + " expected but was " + argument.getClass()
                        .getName());
    }

    JCas jCas = ((StandaloneArgument) argument).getJCas();

    if (jCas == null) {
        throw new IllegalStateException("Empty jCas for " + argument.getId());
    }

    return keepArgument(jCas);
}
 

import org.apache.uima.jcas.JCas; //导入依赖的package包/类
@Override
public boolean keepArgument(JCas jCas)
{
    List<Sentence> sentences = new ArrayList<>(JCasUtil.select(jCas, Sentence.class));

    // remove one-sentence arguments
    if (sentences.size() == 1) {
        return false;
    }

    for (Sentence s : sentences) {
        if (s.getCoveredText().length() > MAX_SENTENCE_LENGTH) {
            return false;
        }
    }

    return true;
}