Java Paragraph类代码示例

import de.tudarmstadt.ukp.dkpro.core.api.segmentation.type.Paragraph; //导入依赖的package包/类
/**
 * Creates a tokenizing pipeline
 *
 * @throws IOException exception
 */
private static AnalysisEngineDescription getPipeline()
        throws IOException
{
    if (pipelineSingleton == null) {
        try {
            pipelineSingleton = AnalysisEngineFactory.createEngineDescription(
                    AnalysisEngineFactory.createEngineDescription(ParagraphSplitter.class,
                            ParagraphSplitter.PARAM_SPLIT_PATTERN,
                            ParagraphSplitter.SINGLE_LINE_BREAKS_PATTERN),
                    AnalysisEngineFactory.createEngineDescription(ArkTweetTokenizerFixed.class),
                    AnalysisEngineFactory.createEngineDescription(StanfordSegmenter.class,
                            StanfordSegmenter.PARAM_WRITE_TOKEN, false,
                            StanfordSegmenter.PARAM_ZONE_TYPES,
                            Paragraph.class.getCanonicalName()));
        }
        catch (ResourceInitializationException e) {
            throw new IOException();
        }
    }

    return pipelineSingleton;
}
 

import de.tudarmstadt.ukp.dkpro.core.api.segmentation.type.Paragraph; //导入依赖的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 de.tudarmstadt.ukp.dkpro.core.api.segmentation.type.Paragraph; //导入依赖的package包/类
/**
 * Creates paragraph annotations in {@code target} by copying paragraphs from the {@code source}.
 *
 * @param source source jcas
 * @param target target jcas
 * @throws IllegalArgumentException if source text and target text are different or if target
 *                                  already contains paragraph annotations
 */
public static void copyParagraphAnnotations(JCas source, JCas target)
        throws IllegalArgumentException
{
    if (!source.getDocumentText().equals(target.getDocumentText())) {
        throw new IllegalArgumentException(
                "source.documentText and target.documentText are not equal");
    }

    Collection<Paragraph> targetParagraphs = JCasUtil.select(target, Paragraph.class);
    if (!targetParagraphs.isEmpty()) {
        throw new IllegalArgumentException("target already contains paragraph annotations");
    }

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

import de.tudarmstadt.ukp.dkpro.core.api.segmentation.type.Paragraph; //导入依赖的package包/类
/**
 * Returns true if the token has a preceding whitespace in the original document
 *
 * @param token token
 * @param jCas  jcas
 * @return boolen
 */
public static boolean hasSpaceBefore(Token token, JCas jCas)
{
    // select previous token(s)
    List<Token> prevTokens = JCasUtil.selectPreceding(jCas, Token.class, token, 1);

    Paragraph paragraph = JCasUtil.selectCovering(jCas, Paragraph.class, token).iterator()
            .next();

    return !prevTokens.isEmpty() && (prevTokens.iterator().next().getEnd() != token.getBegin())
            && (token.getBegin() != paragraph.getBegin());
}
 

import de.tudarmstadt.ukp.dkpro.core.api.segmentation.type.Paragraph; //导入依赖的package包/类
@Override
public void process(JCas jCas)
    throws AnalysisEngineProcessException
{
	String text = jCas.getDocumentText();
	ArrayList<ParagraphBoundaries> boundaries = getParagraphBoundaries(text);
	Iterator<ParagraphBoundaries> it = boundaries.iterator();
	while(it.hasNext()) {
		ParagraphBoundaries p = it.next();
		//System.out.println(p.getBegin() + " " + p.getEnd());
		new Paragraph(jCas, p.getBegin(), p.getEnd()).addToIndexes();
	}
}
 

import de.tudarmstadt.ukp.dkpro.core.api.segmentation.type.Paragraph; //导入依赖的package包/类
public static List<String> renderDocumentToHtmlParagraphs(JCas jCas)
{
    List<String> result = new ArrayList<>();

    // iterate over paragraphs
    for (Paragraph p : JCasUtil.select(jCas, Paragraph.class)) {
        StringWriter writer = new StringWriter();
        PrintWriter out = new PrintWriter(writer);
        // iterate over tokens
        for (Token t : JCasUtil.selectCovered(jCas, Token.class, p)) {
            // print token's preceding space if needed
            if (ArgumentPrinterUtils.hasSpaceBefore(t, jCas)) {
                out.print(" ");
            }

            // does an argument concept begin here?
            ArgumentComponent argumentConcept = ArgumentPrinterUtils
                    .argAnnotationBegins(t, jCas);
            if (argumentConcept != null) {
                String additionalInfo = "";
                if (argumentConcept instanceof Claim) {
                    additionalInfo = " [stance: " + ((Claim) argumentConcept).getStance() + "]";
                }
                out.printf("<span class=\"component\">%s%s:</span> <span class=\"%s\">",
                        argumentConcept.getClass().getSimpleName().toLowerCase(),
                        additionalInfo,
                        argumentConcept.getClass().getSimpleName().toLowerCase());
            }

            Sentence sentence = ArgumentPrinterUtils.sentenceStartsOnToken(t);
            if (sentence != null) {
                out.printf("<span class=\"sentence\">S%d</span>",
                        ArgumentPrinterUtils.getSentenceNumber(sentence, jCas));
            }

            // print token
            out.print(t.getCoveredText());

            // does an argument concept end here?
            if (ArgumentPrinterUtils.argAnnotationEnds(t, jCas)) {
                out.print("</span>");
            }
        }

        result.add(writer.toString());
    }

    return result;
}
 

import de.tudarmstadt.ukp.dkpro.core.api.segmentation.type.Paragraph; //导入依赖的package包/类
/**
 * Returns the number of {@link Paragraph} in the CAS.
 *
 * @param aJCas the CAS
 * @return the paragraph count
 */
public static int getParagraphCount(final JCas aJCas)
{
    return count(Paragraph.class, aJCas);
}