Example usage for org.jdom2.output XMLOutputter XMLOutputter

List of usage examples for org.jdom2.output XMLOutputter XMLOutputter

  1. HOME
  2. Java
  3. org.jdom2
  4. org.jdom2.output.*
  5. XMLOutputter
  6. XMLOutputter

Introduction

In this page you can find the example usage for org.jdom2.output XMLOutputter XMLOutputter.

Prototype

public XMLOutputter()

Source Link

Document

This will create an XMLOutputter with a default Format and XMLOutputProcessor .

Usage

From source file:es.uvigo.ei.sing.rubioseq.gui.view.models.experiments.MethylationExperiment.java

License:Open Source License

public void generateXMLConfigurationFile(File output) throws IOException {
    Document configurationFile = new Document();
    Element configData = new Element(CONFIG_DATA);
    configurationFile.setRootElement(configData);
    configData.setAttribute(ExperimentUtils.BRANCH, ExperimentUtils.BRANCH_METHYLATION);

    Element referencePath = new Element(REFERENCEPATH);
    referencePath.addContent(this.getReferencePath().getFile().getAbsolutePath());
    configurationFile.getRootElement().addContent(referencePath);

    Element readsPath = new Element(READSPATH);
    readsPath.addContent(this.getReadsPath().getFile().getAbsolutePath());
    configurationFile.getRootElement().addContent(readsPath);

    Element projectCompletePath = new Element(PROJECT_COMPLETE_PATH);
    projectCompletePath.addContent(this.getProjectCompletePath().getFile().getAbsolutePath());
    configurationFile.getRootElement().addContent(projectCompletePath);

    Element plattform = new Element(PLATTFORM);
    plattform.addContent(this.getPlattform().getDisplayName());
    configurationFile.getRootElement().addContent(plattform);

    Element methylType = new Element(METHYLTYPE);
    methylType.addContent(this.getMethylType().toString());
    configurationFile.getRootElement().addContent(methylType);

    for (MethylationSample ms : this.getSamples()) {
        Element sample1 = new Element(SAMPLE1);
        sample1.addContent(ms.getSample1().getFile().getName());
        configurationFile.getRootElement().addContent(sample1);
    }/*ww w  .j a  va2  s. co m*/

    for (MethylationSample ms : this.getSamples()) {
        if (ms.getSample2() != null) {
            Element sample2 = new Element(SAMPLE2);
            sample2.addContent(ms.getSample2().getFile().getName());
            configurationFile.getRootElement().addContent(sample2);
        }
    }

    if (!this.getSeedLength().equals(seedLength_DV)) {
        Element seedLength = new Element(SEED_LENGTH);
        seedLength.addContent(this.getSeedLength().toString());
        configurationFile.getRootElement().addContent(seedLength);
    }

    if (!this.getNumMis().equals(numMis_DV)) {
        Element numMiss = new Element(NUM_MIS);
        numMiss.addContent(this.getNumMis().toString());
        configurationFile.getRootElement().addContent(numMiss);
    }

    if (this.getIntervalsPath() != intervalsPath_DV) {
        Element intervalsPath = new Element(INTERVALS);
        intervalsPath.addContent(this.getIntervalsPath().getFile().getAbsolutePath());
        configurationFile.getRootElement().addContent(intervalsPath);
    }

    if (!this.getContextType().equals(contextType_DV)) {
        Element contextType = new Element(CONTEXT);
        contextType.addContent(this.getContextType().toString());
        configurationFile.getRootElement().addContent(contextType);
    }

    if (!this.getTrimTagLength().equals(trimTagLength_DV)) {
        Element trimTagLength = new Element(TRIMTAGLENGTH);
        trimTagLength.addContent(this.getTrimTagLength());
        configurationFile.getRootElement().addContent(trimTagLength);
    }

    if (!this.getMinQual().equals(minQual_DV)) {
        Element minQual = new Element(MINQUAL);
        minQual.addContent(this.getMinQual().toString());
        configurationFile.getRootElement().addContent(minQual);
    }

    if (!this.getFastqc().equals(fastqc_DV)) {
        Element fastqc = new Element(FASTQC);
        fastqc.addContent(this.getFastqc().toString());
        configurationFile.getRootElement().addContent(fastqc);
    }

    if (!this.getDepthFilter().equals(depthFilter_DV)) {
        Element depthFilter = new Element(DEPTHFILTER);
        depthFilter.addContent(this.getDepthFilter().toString());
        configurationFile.getRootElement().addContent(depthFilter);
    }

    if (!this.getQueueSGEProject().equals(queueSGEProject_DV)) {
        Element queueProject = new Element(QUEUESGEPROJECT);
        queueProject.addContent(this.getQueueSGEProject().toString());
        configurationFile.getRootElement().addContent(queueProject);
    }

    if (!this.getMultiExec().equals(multiExec_DV)) {
        Element multiExec = new Element(MULTIEXEC);
        multiExec.addContent(this.getMultiExec().toString());
        configurationFile.getRootElement().addContent(multiExec);
    }

    XMLOutputter xmlOutput = new XMLOutputter();
    xmlOutput.setFormat(Format.getPrettyFormat());
    xmlOutput.output(configurationFile, new FileWriter(output));
}

From source file:es.uvigo.ei.sing.rubioseq.gui.view.models.experiments.SingleNucleotideVariantExperiment.java

License:Open Source License

public void generateXMLConfigurationFile(File output) throws IOException {
    Document configurationFile = new Document();
    Element configData = new Element(CONFIG_DATA);
    configurationFile.setRootElement(configData);
    configData.setAttribute(ExperimentUtils.BRANCH, ExperimentUtils.BRANCH_SNV);

    Element genRef = new Element(GENREF);
    genRef.addContent(this.getGenRefPath().getFile().getAbsolutePath());
    configurationFile.getRootElement().addContent(genRef);

    Element dbSnpAnnot = new Element(DBSNPANNOT);
    dbSnpAnnot.addContent(this.getDbSnpAnnotPath().getFile().getAbsolutePath());
    configurationFile.getRootElement().addContent(dbSnpAnnot);

    Element genomes1000Annot = new Element(GENOMES1000ANNOT);
    genomes1000Annot.addContent(this.getGenomes1000AnnotPath().getFile().getAbsolutePath());
    configurationFile.getRootElement().addContent(genomes1000Annot);

    Element indelAnnot = new Element(INDELANNOT);
    indelAnnot.addContent(this.getIndelAnnotPath().getFile().getAbsolutePath());
    configurationFile.getRootElement().addContent(indelAnnot);

    if (this.getIntervalsPath() != getIntervalsPath_DV()) {
        Element intervals = new Element(INTERVALS);
        intervals.addContent(this.getIntervalsPath().getFile().getAbsolutePath());
        configurationFile.getRootElement().addContent(intervals);
    }//from   ww  w  .  ja v  a2 s  . c  om

    if (this.getKnownIndels().size() > 0) {
        for (KnownIndels kI : this.getKnownIndels()) {
            Element knownIndels = new Element(KNOWNINDELS);
            knownIndels.addContent(kI.getFile().getFile().getAbsolutePath());
            configurationFile.getRootElement().addContent(knownIndels);
        }
    }

    Element plattform = new Element(PLATTFORM);
    plattform.addContent(this.getPlattform().getDisplayName());
    configurationFile.getRootElement().addContent(plattform);

    if (!this.getCheckCasava().equals(checkCasava_DV)) {
        Element checkCasava = new Element(CHECKCASAVA);
        checkCasava.addContent(this.getCheckCasava().toString());
        configurationFile.getRootElement().addContent(checkCasava);
    }

    Element dirOutBase = new Element(DIROUTBASE);
    dirOutBase.addContent(this.getDirOutBase().getFile().getAbsolutePath());
    configurationFile.getRootElement().addContent(dirOutBase);

    Element projectId = new Element(PROJECTID);
    projectId.addContent(this.getProjectId());
    configurationFile.getRootElement().addContent(projectId);

    if (!this.getUserName().equals(userName_DV)) {
        Element userName = new Element(USERNAME);
        userName.addContent(this.getUserName());
        configurationFile.getRootElement().addContent(userName);
    }

    Element dataInDirpreProcess = new Element(INDIRPREPROCESS);
    dataInDirpreProcess.addContent(this.getDataInDirpreProcess().getFile().getAbsolutePath());
    configurationFile.getRootElement().addContent(dataInDirpreProcess);

    for (Sample s : this.getSamples()) {
        Element sample = new Element(SAMPLE);

        Element sampleName = new Element(SAMPLE_NAME);
        sampleName.addContent(s.getSampleName());
        sample.addContent(sampleName);

        Element sampleFiles = new Element(SAMPLE_FILES);
        sampleFiles.addContent(s.getSampleFiles());
        sample.addContent(sampleFiles);

        Element sampleSuffix = new Element(SAMPLE_SUFFIX);
        sampleSuffix.addContent(s.getSampleSuffix());
        sample.addContent(sampleSuffix);

        Element sampleType = new Element(SAMPLE_TYPE);
        sampleType.addContent(s.getSampleType().getDisplayName());
        sample.addContent(sampleType);

        configurationFile.getRootElement().addContent(sample);
    }

    if (!this.getCallingType().equals(callingType_DV)) {
        Element callingType = new Element(CALLYING_TYPE);
        callingType.addContent(this.getCallingType().toString());
        configurationFile.getRootElement().addContent(callingType);
    }

    if (!this.getgATKoutputMode().equals(gATKoutputMode_DV)) {
        Element gATKoutputModeoutputMode = new Element(GATKOUTPUTMODE);
        gATKoutputModeoutputMode.addContent(this.getgATKoutputMode().toString());
        configurationFile.getRootElement().addContent(gATKoutputModeoutputMode);
    }

    if (!this.getRsFilter().equals(rsFilter_DV)) {
        Element rsFilter = new Element(RSFILTER);
        rsFilter.addContent(this.getRsFilter().toString());
        configurationFile.getRootElement().addContent(rsFilter);
    }

    if (!this.getrUbioSeqMode().equals(rUbioSeqMode_DV)) {
        Element rUbioSeq_Mode = new Element(RUBIOSEQMODE);
        rUbioSeq_Mode.addContent(this.getrUbioSeqMode().toString());
        configurationFile.getRootElement().addContent(rUbioSeq_Mode);
    }

    if (!this.getFastqc().equals(fastqc_DV)) {
        Element fastqc = new Element(FASTQC);
        fastqc.addContent(this.getFastqc().toString());
        configurationFile.getRootElement().addContent(fastqc);
    }

    if (!this.getvEPFlag().equals(vEPFlag_DV)) {
        Element vEPFlag = new Element(VEPFLAG);
        vEPFlag.addContent(this.getvEPFlag().toString());
        configurationFile.getRootElement().addContent(vEPFlag);
    }

    if (!this.gettCFlag().equals(tCFlag_DV)) {
        Element tCFlag = new Element(TCFLAG);
        tCFlag.addContent(this.gettCFlag().toString());
        configurationFile.getRootElement().addContent(tCFlag);
    }

    if (!this.getmDFlag().equals(mDFlag_DV)) {
        Element mDFlag = new Element(MDFLAG);
        mDFlag.addContent(this.getmDFlag().toString());
        configurationFile.getRootElement().addContent(mDFlag);
    }

    if (!this.getStandCallConf().equals(standCallConf_DV)) {
        Element standCallConf = new Element(STANDCALLCONF);
        standCallConf.addContent(this.getStandCallConf().toString());
        configurationFile.getRootElement().addContent(standCallConf);
    }

    if (!this.getStandEmitConf().equals(standEmitConf_DV)) {
        Element standEmitConf = new Element(STANDEMITCONF);
        standEmitConf.addContent(this.getStandEmitConf().toString());
        configurationFile.getRootElement().addContent(standEmitConf);
    }

    if (!this.getQueueSGEProject().equals(queueSGEProject_DV)) {
        Element queueSGEProject = new Element(QUEUESGEPROJECT);
        queueSGEProject.addContent(this.getQueueSGEProject().toString());
        configurationFile.getRootElement().addContent(queueSGEProject);
    }

    if (this.getChoiceVqrsHardFilters().equals(VQRSHardFiltersChoice.VQRS)
            && this.getvQSRblockMills() != VQSRblockMills_DV && this.getvQSRblockHapMAp() != VQSRblockHapMAp_DV
            && this.getvQSRblockThousandG() != VQSRblockThousandG_DV) {

        Element vQSR_block = new Element(VQSRBLOCK);

        Element mills = new Element(MILLS);
        mills.addContent(this.getvQSRblockMills().getFile().getAbsolutePath());
        vQSR_block.addContent(mills);

        Element hapmap = new Element(HAPMAP);
        hapmap.addContent(this.getvQSRblockHapMAp().getFile().getAbsolutePath());
        vQSR_block.addContent(hapmap);

        Element thousandg = new Element(THOUSANDG);
        thousandg.addContent(this.getvQSRblockThousandG().getFile().getAbsolutePath());
        vQSR_block.addContent(thousandg);

        configurationFile.getRootElement().addContent(vQSR_block);
    }

    if (this.getChoiceVqrsHardFilters().equals(VQRSHardFiltersChoice.HARDFILTERS)
            && (!this.getminQual().equals(minQual_DV) || !this.getdPmin().equals(DPmin_DV)
                    || this.getHardFilters().size() > 0)) {

        Element hardFiltersBlock = new Element(HFILTERS);

        if (!this.getdPmin().equals(DPmin_DV)) {
            Element dpMin = new Element(DPMIN);
            dpMin.addContent(this.getdPmin().toString());
            hardFiltersBlock.addContent(dpMin);
        }

        if (!this.getminQual().equals(minQual_DV)) {
            Element minQual = new Element(MINQUAL);
            minQual.addContent(this.getminQual().toString());
            hardFiltersBlock.addContent(minQual);
        }

        for (HardFilter hF : this.getHardFilters()) {
            Element name = hF.getType().equals(HardFilter.HFilterType.SNP) ? new Element(HFILTER_NAME_SNP)
                    : new Element(HFILTER_NAME_INDEL);
            name.addContent(hF.getName());
            Element rule = hF.getType().equals(HardFilter.HFilterType.SNP) ? new Element(HFILTER_RULE_SNP)
                    : new Element(HFILTER_RULE_INDEL);
            rule.addContent(hF.getRule());
            hardFiltersBlock.addContent(name);
            hardFiltersBlock.addContent(rule);
        }

        configurationFile.getRootElement().addContent(hardFiltersBlock);
    }

    XMLOutputter xmlOutput = new XMLOutputter();
    xmlOutput.setFormat(Format.getPrettyFormat());
    xmlOutput.output(configurationFile, new FileWriter(output));
}

From source file:eu.himeros.cophi.ocr.proofreader.controller.pojo.HocrDocumentExistSaver.java

License:Open Source License

@Override
public void save(Document hocrDocument, Map<String, Object> destination) {
    try {/* w w  w .  java  2 s .c o m*/
        //String library=destination.get("library");
        //String book=library+"/"+destination.get("book");
        //String page=destination.get("page");
        //String login=destination.get("login");
        //String password=destination.get("password");
        //Database database = (Database)(Class.forName("org.exist.xmldb.DatabaseImpl").newInstance());
        //DatabaseManager.registerDatabase(database);
        //Collection col = DatabaseManager.getCollection(book,login,password);
        Collection libCol = (Collection) destination.get("library");
        System.err.println(destination.get("library"));
        //System.err.println(((Collection)destination.get("library")).toString());
        System.err.println((String) destination.get("book"));
        System.err
                .println(((Collection) libCol.getChildCollection((String) destination.get("book"))).toString());
        System.err.println("err");
        Collection bookCol = libCol.getChildCollection((String) destination.get("book"));
        XMLResource res = (XMLResource) bookCol.createResource((String) destination.get("page"), "XMLResource");
        //DOMOutputter domOutputter=new DOMOutputter();
        XMLOutputter xmlOutputter = new XMLOutputter();
        String resStr = xmlOutputter.outputString(hocrDocument);
        //org.w3c.dom.Document domDoc=domOutputter.output(hocrDocument);
        res.setContent(resStr);
        System.err.println(resStr);
        bookCol.storeResource(res);
        ((EXistResource) res).freeResources();
    } catch (XMLDBException ex) {
        Logger.getLogger(HocrDocumentExistSaver.class.getName()).log(Level.SEVERE, null, ex);
    }
}

From source file:eu.optimis.monitoring.amazoncollector.XMLHelper.java

License:Apache License

public static String createDocument(List<Measurement> measurements) {

    Element root = new Element(ROOT);
    Document doc = new Document(root);

    for (Measurement m : measurements) {
        root.addContent(createMonitoringResource(m));
    }//from   w  ww.  ja  va 2 s.c  o m

    XMLOutputter outputter = new XMLOutputter();
    outputter.setFormat(Format.getPrettyFormat());
    try {
        outputter.output(doc, new FileOutputStream("./aws.xml"));
    } catch (FileNotFoundException ex) {
        Logger.getLogger(XMLHelper.class.getName()).log(Level.SEVERE, null, ex);
    } catch (IOException ex) {
        Logger.getLogger(XMLHelper.class.getName()).log(Level.SEVERE, null, ex);
    }

    String xmlResult = outputter.outputString(doc);
    String result = xmlResult.replace("encoding=\"UTF-8\"", "");
    //System.out.println (result);
    return result;
}

From source file:eus.ixa.ixa.pipe.convert.AbsaSemEval.java

License:Apache License

public static String nafToAbsa2015(String inputNAF) throws IOException {

    Path kafPath = Paths.get(inputNAF);
    KAFDocument kaf = KAFDocument.createFromFile(kafPath.toFile());
    Set<String> reviewIds = getReviewIdsFromXpathAttribute(kaf);

    // root element in ABSA 2015 and 2016 format
    Element reviewsElem = new Element("Reviews");
    Document doc = new Document(reviewsElem);

    // creating Reviews children of Review
    for (String reviewId : reviewIds) {
        Element reviewElem = new Element("Review");
        reviewElem.setAttribute("rid", reviewId);
        Element sentencesElem = new Element("sentences");
        // getting the sentences in the review
        List<List<WF>> sentencesByReview = getSentencesByReview(kaf, reviewId);
        for (List<WF> sent : sentencesByReview) {
            String sentId = sent.get(0).getXpath();
            Integer sentNumber = sent.get(0).getSent();

            // getting text element from word forms in NAF
            String textString = NAFUtils.getSentenceStringFromWFs(sent);
            Element sentenceElem = new Element("sentence");
            sentenceElem.setAttribute("id", sentId);
            Element textElem = new Element("text");
            textElem.setText(textString);
            sentenceElem.addContent(textElem);

            // creating opinions element for sentence
            List<Opinion> opinionsBySentence = getOpinionsBySentence(kaf, sentNumber);
            Element opinionsElem = new Element("Opinions");
            if (!opinionsBySentence.isEmpty()) {
                // getting opinion info from NAF Opinion layer
                for (Opinion opinion : opinionsBySentence) {
                    Element opinionElem = new Element("Opinion");
                    // String polarity = opinion.getOpinionExpression().getPolarity();
                    String category = opinion.getOpinionExpression().getSentimentProductFeature();
                    String targetString = opinion.getStr();
                    int fromOffset = opinion.getOpinionTarget().getTerms().get(0).getWFs().get(0).getOffset();
                    List<WF> targetWFs = opinion.getOpinionTarget().getTerms()
                            .get(opinion.getOpinionTarget().getTerms().size() - 1).getWFs();
                    int toOffset = targetWFs.get(targetWFs.size() - 1).getOffset()
                            + targetWFs.get(targetWFs.size() - 1).getLength();
                    opinionElem.setAttribute("target", targetString);
                    opinionElem.setAttribute("category", category);
                    // TODO we still do not have polarity here
                    opinionElem.setAttribute("polarity", "na");
                    opinionElem.setAttribute("from", Integer.toString(fromOffset));
                    opinionElem.setAttribute("to", Integer.toString(toOffset));
                    opinionsElem.addContent(opinionElem);
                }/*from   w w  w . j a v  a  2s .  c o m*/
            }
            sentenceElem.addContent(opinionsElem);
            sentencesElem.addContent(sentenceElem);
        }
        reviewElem.addContent(sentencesElem);
        reviewsElem.addContent(reviewElem);
    } // end of review

    XMLOutputter xmlOutput = new XMLOutputter();
    Format format = Format.getPrettyFormat();
    xmlOutput.setFormat(format);
    return xmlOutput.outputString(doc);
}

From source file:eus.ixa.ixa.pipe.convert.AbsaSemEval.java

License:Apache License

public static String nafToAbsa2014(String kafDocument) {

    KAFDocument kaf = null;/*from  w w w. j a v a 2 s  .  co  m*/
    try {
        Path kafPath = Paths.get(kafDocument);
        kaf = KAFDocument.createFromFile(kafPath.toFile());
    } catch (IOException e) {
        e.printStackTrace();
    }
    Element sentencesElem = new Element("sentences");
    Document doc = new Document(sentencesElem);

    for (List<WF> sent : kaf.getSentences()) {
        String sentId = sent.get(0).getXpath();
        Integer sentNumber = sent.get(0).getSent();

        // getting text element from WFs in NAF
        String textString = NAFUtils.getSentenceStringFromWFs(sent);
        Element sentenceElem = new Element("sentence");
        sentenceElem.setAttribute("id", sentId);
        Element textElem = new Element("text");
        textElem.setText(textString);
        sentenceElem.addContent(textElem);

        // creating opinions element for sentence
        List<Opinion> opinionsBySentence = getOpinionsBySentence(kaf, sentNumber);
        if (!opinionsBySentence.isEmpty()) {
            Element aspectTerms = new Element("aspectTerms");
            // getting opinion info from NAF Opinion layer
            for (Opinion opinion : opinionsBySentence) {
                String polarity = "";
                String targetString = opinion.getStr();
                int fromOffset = opinion.getOpinionTarget().getTerms().get(0).getWFs().get(0).getOffset();
                List<WF> targetWFs = opinion.getOpinionTarget().getTerms()
                        .get(opinion.getOpinionTarget().getTerms().size() - 1).getWFs();
                int toOffset = targetWFs.get(targetWFs.size() - 1).getOffset()
                        + targetWFs.get(targetWFs.size() - 1).getLength();

                Element aspectTerm = new Element("aspectTerm");
                aspectTerm.setAttribute("term", targetString);
                aspectTerm.setAttribute("polarity", polarity);
                aspectTerm.setAttribute("from", Integer.toString(fromOffset));
                aspectTerm.setAttribute("to", Integer.toString(toOffset));
                aspectTerms.addContent(aspectTerm);
            }
            sentenceElem.addContent(aspectTerms);
        }
        sentencesElem.addContent(sentenceElem);
    }
    XMLOutputter xmlOutput = new XMLOutputter();
    Format format = Format.getPrettyFormat();
    xmlOutput.setFormat(format);
    return xmlOutput.outputString(doc);
}

From source file:eus.ixa.ixa.pipe.ml.document.features.DocumentFeatureDescriptor.java

License:Apache License

/**
 * Generate the XML feature descriptor from the docTrainer.properties file.
 * //from w w  w.j a  v a 2 s.  com
 * @param params
 *          the properties file
 * @return the XML feature descriptor
 * @throws IOException
 *           if input output fails
 */
public static String createDocumentFeatureDescriptor(final TrainingParameters params) throws IOException {

    // <generators>
    final Element generators = new Element("generators");
    final Document doc = new Document(generators);

    // <custom bagofwords /.
    if (Flags.isBagOfWordsFeature(params)) {
        final String tokenFeatureRange = Flags.getBagOfWordsFeaturesRange(params);
        final Element tokenFeature = new Element("custom");
        tokenFeature.setAttribute("class", BagOfWordsFeatureGenerator.class.getName());
        tokenFeature.setAttribute("range", tokenFeatureRange);
        generators.addContent(tokenFeature);
        System.err.println("-> BOW features added!");
    }
    if (Flags.isTokenClassFeature(params)) {
        final String tokenClassFeatureRange = Flags.getTokenClassFeaturesRange(params);
        final Element tokenClassFeature = new Element("custom");
        tokenClassFeature.setAttribute("class", DocTokenClassFeatureGenerator.class.getName());
        tokenClassFeature.setAttribute("range", tokenClassFeatureRange);
        generators.addContent(tokenClassFeature);
        System.err.println("-> Token Class Features added!");
    }
    if (Flags.isOutcomePriorFeature(params)) {
        final Element outcomePriorFeature = new Element("custom");
        outcomePriorFeature.setAttribute("class", DocOutcomePriorFeatureGenerator.class.getName());
        generators.addContent(outcomePriorFeature);
        System.err.println("-> Outcome Prior Features added!");
    }
    if (Flags.isSentenceFeature(params)) {
        final String beginSentence = Flags.getSentenceFeaturesBegin(params);
        final String endSentence = Flags.getSentenceFeaturesEnd(params);
        final Element sentenceFeature = new Element("custom");
        sentenceFeature.setAttribute("class", DocSentenceFeatureGenerator.class.getName());
        sentenceFeature.setAttribute("begin", beginSentence);
        sentenceFeature.setAttribute("end", endSentence);
        generators.addContent(sentenceFeature);
        System.err.println("-> Sentence Features added!");
    }
    if (Flags.isPrefixFeature(params)) {
        final String beginPrefix = Flags.getPrefixFeaturesBegin(params);
        final String endPrefix = Flags.getPrefixFeaturesEnd(params);
        final Element prefixFeature = new Element("custom");
        prefixFeature.setAttribute("class", DocPrefixFeatureGenerator.class.getName());
        prefixFeature.setAttribute("begin", beginPrefix);
        prefixFeature.setAttribute("end", endPrefix);
        generators.addContent(prefixFeature);
        System.err.println("-> Prefix Features added!");
    }
    if (Flags.isSuffixFeature(params)) {
        final String beginSuffix = Flags.getSuffixFeaturesBegin(params);
        final String endSuffix = Flags.getSuffixFeaturesEnd(params);
        final Element suffixFeature = new Element("custom");
        suffixFeature.setAttribute("class", DocSuffixFeatureGenerator.class.getName());
        suffixFeature.setAttribute("begin", beginSuffix);
        suffixFeature.setAttribute("end", endSuffix);
        generators.addContent(suffixFeature);
        System.err.println("-> Suffix Features added!");
    }
    if (Flags.isNgramFeature(params)) {
        final String charngramRange = Flags.getNgramFeaturesRange(params);
        final String[] rangeArray = Flags.processNgramRange(charngramRange);
        final Element charngramFeature = new Element("custom");
        charngramFeature.setAttribute("class", NGramFeatureGenerator.class.getName());
        charngramFeature.setAttribute("minLength", rangeArray[0]);
        charngramFeature.setAttribute("maxLength", rangeArray[1]);
        generators.addContent(charngramFeature);
        System.err.println("-> Ngram Features added!");
    }
    if (Flags.isCharNgramClassFeature(params)) {
        final String charngramRange = Flags.getCharNgramFeaturesRange(params);
        final String[] rangeArray = Flags.processNgramRange(charngramRange);
        final Element charngramFeature = new Element("custom");
        charngramFeature.setAttribute("class", DocCharacterNgramFeatureGenerator.class.getName());
        charngramFeature.setAttribute("minLength", rangeArray[0]);
        charngramFeature.setAttribute("maxLength", rangeArray[1]);
        generators.addContent(charngramFeature);
        System.err.println("-> CharNgram Class Features added!");
    }
    // Polarity Dictionary Features
    if (Flags.isDictionaryPolarityFeatures(params)) {
        final String dictPath = Flags.getDictionaryPolarityFeatures(params);
        final List<File> fileList = StringUtils.getFilesInDir(new File(dictPath));
        for (final File dictFile : fileList) {
            final Element dictFeatures = new Element("custom");
            dictFeatures.setAttribute("class", DocPolarityDictionaryFeatureGenerator.class.getName());
            dictFeatures.setAttribute("dict", IOUtils.normalizeLexiconName(dictFile.getName()));
            generators.addContent(dictFeatures);
        }
        System.err.println("-> Dictionary Features added!");
    }
    // Frequent Word Features
    if (Flags.isFrequentWordFeatures(params)) {
        final String dictPath = Flags.getFrequentWordFeatures(params);
        final List<File> fileList = StringUtils.getFilesInDir(new File(dictPath));
        for (final File dictFile : fileList) {
            final Element dictFeatures = new Element("custom");
            dictFeatures.setAttribute("class", FrequentWordFeatureGenerator.class.getName());
            dictFeatures.setAttribute("dict", IOUtils.normalizeLexiconName(dictFile.getName()));
            generators.addContent(dictFeatures);
        }
        System.err.println("-> Frequent Word Features added!");
    }
    //Opinion Target Extraction Features
    if (Flags.isTargetFeatures(params)) {
        final String targetModelPath = Flags.getTargetFeatures(params);
        final String targetModelRange = Flags.getTargetFeaturesRange(params);
        final Element targetClassFeatureElement = new Element("custom");
        targetClassFeatureElement.setAttribute("class", DocTargetFeatureGenerator.class.getName());
        targetClassFeatureElement.setAttribute("model",
                IOUtils.normalizeLexiconName(new File(targetModelPath).getName()));
        targetClassFeatureElement.setAttribute("range", targetModelRange);
        generators.addContent(targetClassFeatureElement);
        System.err.println("-> Target Model Features added!");
    }
    // Dictionary Features
    if (Flags.isDictionaryFeatures(params)) {
        final String dictPath = Flags.getDictionaryFeatures(params);
        final String seqCodec = Flags.getSequenceCodec(params);
        final List<File> fileList = StringUtils.getFilesInDir(new File(dictPath));
        for (final File dictFile : fileList) {
            final Element dictFeatures = new Element("custom");
            dictFeatures.setAttribute("class", DocDictionaryFeatureGenerator.class.getName());
            dictFeatures.setAttribute("dict", IOUtils.normalizeLexiconName(dictFile.getName()));
            dictFeatures.setAttribute("seqCodec", seqCodec);
            generators.addContent(dictFeatures);
        }
        System.err.println("-> Dictionary Features added!");
    }
    // Brown clustering features
    if (Flags.isBrownFeatures(params)) {
        final String brownClusterPath = Flags.getBrownFeatures(params);
        final List<File> brownClusterFiles = Flags.getClusterLexiconFiles(brownClusterPath);
        for (final File brownClusterFile : brownClusterFiles) {
            // brown bigram class features
            final Element brownBigramFeatures = new Element("custom");
            brownBigramFeatures.setAttribute("class", DocBrownBigramFeatureGenerator.class.getName());
            brownBigramFeatures.setAttribute("dict", IOUtils.normalizeLexiconName(brownClusterFile.getName()));
            //generators.addContent(brownBigramFeatures);
            // brown token feature
            final Element brownTokenFeature = new Element("custom");
            brownTokenFeature.setAttribute("class", DocBrownTokenFeatureGenerator.class.getName());
            brownTokenFeature.setAttribute("dict", IOUtils.normalizeLexiconName(brownClusterFile.getName()));
            generators.addContent(brownTokenFeature);
            // brown token class feature
            final Element brownTokenClassFeature = new Element("custom");
            brownTokenClassFeature.setAttribute("class", DocBrownTokenClassFeatureGenerator.class.getName());
            brownTokenClassFeature.setAttribute("dict",
                    IOUtils.normalizeLexiconName(brownClusterFile.getName()));
            //generators.addContent(brownTokenClassFeature);
        }
        System.err.println("-> Brown Cluster Features added!");
    }
    // Clark clustering features
    if (Flags.isClarkFeatures(params)) {
        final String clarkClusterPath = Flags.getClarkFeatures(params);
        final List<File> clarkClusterFiles = Flags.getClusterLexiconFiles(clarkClusterPath);
        for (final File clarkCluster : clarkClusterFiles) {
            final Element clarkFeatures = new Element("custom");
            clarkFeatures.setAttribute("class", DocClarkFeatureGenerator.class.getName());
            clarkFeatures.setAttribute("dict", IOUtils.normalizeLexiconName(clarkCluster.getName()));
            generators.addContent(clarkFeatures);
        }
        System.err.println("-> Clark Cluster Features added!");
    }
    // word2vec clustering features
    if (Flags.isWord2VecClusterFeatures(params)) {
        final String word2vecClusterPath = Flags.getWord2VecClusterFeatures(params);
        final List<File> word2vecClusterFiles = Flags.getClusterLexiconFiles(word2vecClusterPath);
        for (final File word2vecFile : word2vecClusterFiles) {
            final Element word2vecClusterFeatures = new Element("custom");
            word2vecClusterFeatures.setAttribute("class", DocWord2VecClusterFeatureGenerator.class.getName());
            word2vecClusterFeatures.setAttribute("dict", IOUtils.normalizeLexiconName(word2vecFile.getName()));
            generators.addContent(word2vecClusterFeatures);
        }
        System.err.println("-> Word2Vec Clusters Features added!");
    }
    // Morphological features
    if (Flags.isPOSTagModelFeatures(params)) {
        final String posModelPath = Flags.getPOSTagModelFeatures(params);
        final String posModelRange = Flags.getPOSTagModelFeaturesRange(params);
        final Element posTagClassFeatureElement = new Element("custom");
        posTagClassFeatureElement.setAttribute("class", DocPOSTagModelFeatureGenerator.class.getName());
        posTagClassFeatureElement.setAttribute("model",
                IOUtils.normalizeLexiconName(new File(posModelPath).getName()));
        posTagClassFeatureElement.setAttribute("range", posModelRange);
        generators.addContent(posTagClassFeatureElement);
        System.err.println("-> POSTagModel Features added!");
    }
    if (Flags.isLemmaModelFeatures(params)) {
        final String lemmaModelPath = Flags.getLemmaModelFeatures(params);
        final Element lemmaClassFeatureElement = new Element("custom");
        lemmaClassFeatureElement.setAttribute("class", DocLemmaModelFeatureGenerator.class.getName());
        lemmaClassFeatureElement.setAttribute("model",
                IOUtils.normalizeLexiconName(new File(lemmaModelPath).getName()));
        generators.addContent(lemmaClassFeatureElement);
        System.err.println("-> LemmaModel Features added!");
    }
    if (Flags.isLemmaDictionaryFeatures(params)) {
        final String lemmaDictPath = Flags.getLemmaDictionaryFeatures(params);
        final String[] lemmaDictResources = Flags.getLemmaDictionaryResources(lemmaDictPath);
        final Element lemmaClassFeatureElement = new Element("custom");
        lemmaClassFeatureElement.setAttribute("class", DocLemmaDictionaryFeatureGenerator.class.getName());
        lemmaClassFeatureElement.setAttribute("model",
                IOUtils.normalizeLexiconName(new File(lemmaDictResources[0]).getName()));
        lemmaClassFeatureElement.setAttribute("dict",
                IOUtils.normalizeLexiconName(new File(lemmaDictResources[1]).getName()));
        generators.addContent(lemmaClassFeatureElement);
        System.err.println("-> LemmaDictionary Features added!");
    }
    final XMLOutputter xmlOutput = new XMLOutputter();
    final Format format = Format.getPrettyFormat();
    xmlOutput.setFormat(format);
    return xmlOutput.outputString(doc);

}

From source file:eus.ixa.ixa.pipe.ml.features.XMLFeatureDescriptor.java

License:Apache License

/**
 * Generate the XML feature descriptor from the TrainingParameters prop file.
 * @param params the properties file//from w  ww.j a  va 2  s  .c o  m
 * @return the XML feature descriptor
 * @throws IOException if input output fails
 */
public static String createXMLFeatureDescriptor(TrainingParameters params) throws IOException {

    Element aggGenerators = new Element("generators");
    Document doc = new Document(aggGenerators);

    //<generators>
    //  <cache>
    //    <generators>
    Element cached = new Element("cache");
    Element generators = new Element("generators");
    //<window prevLength="2" nextLength="2">
    //  <token />
    //</window>
    if (Flags.isTokenFeature(params)) {
        setWindow(params);
        String tokenFeatureRange = Flags.getTokenFeaturesRange(params);
        Element tokenFeature = new Element("custom");
        tokenFeature.setAttribute("class", TokenFeatureGenerator.class.getName());
        tokenFeature.setAttribute("range", tokenFeatureRange);
        Element tokenWindow = new Element("window");
        tokenWindow.setAttribute("prevLength", Integer.toString(leftWindow));
        tokenWindow.setAttribute("nextLength", Integer.toString(rightWindow));
        tokenWindow.addContent(tokenFeature);
        generators.addContent(tokenWindow);
        System.err.println("-> Token features added!: Window range " + leftWindow + ":" + rightWindow);
    }
    if (Flags.isTokenClassFeature(params)) {
        setWindow(params);
        String tokenClassFeatureRange = Flags.getTokenClassFeaturesRange(params);
        Element tokenClassFeature = new Element("custom");
        tokenClassFeature.setAttribute("class", TokenClassFeatureGenerator.class.getName());
        tokenClassFeature.setAttribute("range", tokenClassFeatureRange);
        Element tokenClassWindow = new Element("window");
        tokenClassWindow.setAttribute("prevLength", Integer.toString(leftWindow));
        tokenClassWindow.setAttribute("nextLength", Integer.toString(rightWindow));
        tokenClassWindow.addContent(tokenClassFeature);
        generators.addContent(tokenClassWindow);
        System.err.println("-> Token Class Features added!: Window range " + leftWindow + ":" + rightWindow);
    }
    if (Flags.isWordShapeSuperSenseFeature(params)) {
        setWindow(params);
        Element wordShapeSuperSenseFeature = new Element("custom");
        wordShapeSuperSenseFeature.setAttribute("class", WordShapeSuperSenseFeatureGenerator.class.getName());
        Element wordShapeWindow = new Element("window");
        wordShapeWindow.setAttribute("prevLength", Integer.toString(leftWindow));
        wordShapeWindow.setAttribute("nextLength", Integer.toString(rightWindow));
        wordShapeWindow.addContent(wordShapeSuperSenseFeature);
        generators.addContent(wordShapeWindow);
        System.err.println(
                "-> Word Shape SuperSense Features added!: Window range " + leftWindow + ":" + rightWindow);
    }
    if (Flags.isOutcomePriorFeature(params)) {
        Element outcomePriorFeature = new Element("custom");
        outcomePriorFeature.setAttribute("class", OutcomePriorFeatureGenerator.class.getName());
        generators.addContent(outcomePriorFeature);
        System.err.println("-> Outcome Prior Features added!");
    }
    if (Flags.isPreviousMapFeature(params)) {
        Element previousMapFeature = new Element("custom");
        previousMapFeature.setAttribute("class", PreviousMapFeatureGenerator.class.getName());
        generators.addContent(previousMapFeature);
        System.err.println("-> Previous Map Features added!");
    }
    if (Flags.isSentenceFeature(params)) {
        String beginSentence = Flags.getSentenceFeaturesBegin(params);
        String endSentence = Flags.getSentenceFeaturesEnd(params);
        Element sentenceFeature = new Element("custom");
        sentenceFeature.setAttribute("class", SentenceFeatureGenerator.class.getName());
        sentenceFeature.setAttribute("begin", beginSentence);
        sentenceFeature.setAttribute("end", endSentence);
        generators.addContent(sentenceFeature);
        System.err.println("-> Sentence Features added!");
    }
    if (Flags.isPrefixFeature(params)) {
        String beginPrefix = Flags.getPrefixFeaturesBegin(params);
        String endPrefix = Flags.getPrefixFeaturesEnd(params);
        Element prefixFeature = new Element("custom");
        prefixFeature.setAttribute("class", PrefixFeatureGenerator.class.getName());
        prefixFeature.setAttribute("begin", beginPrefix);
        prefixFeature.setAttribute("end", endPrefix);
        generators.addContent(prefixFeature);
        System.err.println("-> Prefix Features added!");
    }
    if (Flags.isSuffixFeature(params)) {
        String beginSuffix = Flags.getSuffixFeaturesBegin(params);
        String endSuffix = Flags.getSuffixFeaturesEnd(params);
        Element suffixFeature = new Element("custom");
        suffixFeature.setAttribute("class", SuffixFeatureGenerator.class.getName());
        suffixFeature.setAttribute("begin", beginSuffix);
        suffixFeature.setAttribute("end", endSuffix);
        generators.addContent(suffixFeature);
        System.err.println("-> Suffix Features added!");
    }
    if (Flags.isBigramClassFeature(params)) {
        Element bigramFeature = new Element("custom");
        bigramFeature.setAttribute("class", BigramClassFeatureGenerator.class.getName());
        generators.addContent(bigramFeature);
        System.err.println("-> Bigram Class Features added!");
    }
    if (Flags.isTrigramClassFeature(params)) {
        Element trigramFeature = new Element("custom");
        trigramFeature.setAttribute("class", TrigramClassFeatureGenerator.class.getName());
        generators.addContent(trigramFeature);
        System.err.println("-> Trigram Class Features added!");
    }
    if (Flags.isFourgramClassFeature(params)) {
        Element fourgramFeature = new Element("custom");
        fourgramFeature.setAttribute("class", FourgramClassFeatureGenerator.class.getName());
        generators.addContent(fourgramFeature);
        System.err.println("-> Fourgram Class Features added!");
    }
    if (Flags.isFivegramClassFeature(params)) {
        Element fivegramFeature = new Element("custom");
        fivegramFeature.setAttribute("class", FivegramClassFeatureGenerator.class.getName());
        generators.addContent(fivegramFeature);
        System.err.println("-> Fivegram Class Features added!");
    }
    if (Flags.isCharNgramClassFeature(params)) {
        String charngramRange = Flags.getCharNgramFeaturesRange(params);
        String[] rangeArray = Flags.processNgramRange(charngramRange);
        Element charngramFeature = new Element("custom");
        charngramFeature.setAttribute("class", CharacterNgramFeatureGenerator.class.getName());
        charngramFeature.setAttribute("minLength", rangeArray[0]);
        charngramFeature.setAttribute("maxLength", rangeArray[1]);
        generators.addContent(charngramFeature);
        System.err.println("-> CharNgram Class Features added!");
    }
    //Dictionary Features
    if (Flags.isDictionaryFeatures(params)) {
        setWindow(params);
        String dictPath = Flags.getDictionaryFeatures(params);
        String seqCodec = Flags.getSequenceCodec(params);
        List<File> fileList = StringUtils.getFilesInDir(new File(dictPath));
        for (File dictFile : fileList) {
            Element dictFeatures = new Element("custom");
            dictFeatures.setAttribute("class", DictionaryFeatureGenerator.class.getName());
            dictFeatures.setAttribute("dict", IOUtils.normalizeLexiconName(dictFile.getName()));
            dictFeatures.setAttribute("seqCodec", seqCodec);
            Element dictWindow = new Element("window");
            dictWindow.setAttribute("prevLength", Integer.toString(leftWindow));
            dictWindow.setAttribute("nextLength", Integer.toString(rightWindow));
            dictWindow.addContent(dictFeatures);
            generators.addContent(dictWindow);
        }
        System.err.println("-> Dictionary Features added!");
    }
    //Brown clustering features
    if (Flags.isBrownFeatures(params)) {
        setWindow(params);
        //previous 2 maps features
        Element prev2MapFeature = new Element("custom");
        prev2MapFeature.setAttribute("class", Prev2MapFeatureGenerator.class.getName());
        //generators.addContent(prev2MapFeature);
        //previous map and token feature (in window)
        Element prevMapTokenFeature = new Element("custom");
        prevMapTokenFeature.setAttribute("class", PreviousMapTokenFeatureGenerator.class.getName());
        Element prevMapTokenWindow = new Element("window");
        prevMapTokenWindow.setAttribute("prevLength", Integer.toString(leftWindow));
        prevMapTokenWindow.setAttribute("nextLength", Integer.toString(rightWindow));
        prevMapTokenWindow.addContent(prevMapTokenFeature);
        //generators.addContent(prevMapTokenWindow);
        //brown clustering features
        String brownClusterPath = Flags.getBrownFeatures(params);
        List<File> brownClusterFiles = Flags.getClusterLexiconFiles(brownClusterPath);
        for (File brownClusterFile : brownClusterFiles) {
            //brown bigram class features
            Element brownBigramFeatures = new Element("custom");
            brownBigramFeatures.setAttribute("class", BrownBigramFeatureGenerator.class.getName());
            brownBigramFeatures.setAttribute("dict", IOUtils.normalizeLexiconName(brownClusterFile.getName()));
            generators.addContent(brownBigramFeatures);
            //brown token feature
            Element brownTokenFeature = new Element("custom");
            brownTokenFeature.setAttribute("class", BrownTokenFeatureGenerator.class.getName());
            brownTokenFeature.setAttribute("dict", IOUtils.normalizeLexiconName(brownClusterFile.getName()));
            Element brownTokenWindow = new Element("window");
            brownTokenWindow.setAttribute("prevLength", Integer.toString(leftWindow));
            brownTokenWindow.setAttribute("nextLength", Integer.toString(rightWindow));
            brownTokenWindow.addContent(brownTokenFeature);
            generators.addContent(brownTokenWindow);
            //brown token class feature
            Element brownTokenClassFeature = new Element("custom");
            brownTokenClassFeature.setAttribute("class", BrownTokenClassFeatureGenerator.class.getName());
            brownTokenClassFeature.setAttribute("dict",
                    IOUtils.normalizeLexiconName(brownClusterFile.getName()));
            Element brownTokenClassWindow = new Element("window");
            brownTokenClassWindow.setAttribute("prevLength", Integer.toString(leftWindow));
            brownTokenClassWindow.setAttribute("nextLength", Integer.toString(rightWindow));
            brownTokenClassWindow.addContent(brownTokenClassFeature);
            generators.addContent(brownTokenClassWindow);
        }
        System.err.println("-> Brown Cluster Features added!");
    }
    //Clark clustering features
    if (Flags.isClarkFeatures(params)) {
        setWindow(params);
        String clarkClusterPath = Flags.getClarkFeatures(params);
        List<File> clarkClusterFiles = Flags.getClusterLexiconFiles(clarkClusterPath);
        for (File clarkCluster : clarkClusterFiles) {
            Element clarkFeatures = new Element("custom");
            clarkFeatures.setAttribute("class", ClarkFeatureGenerator.class.getName());
            clarkFeatures.setAttribute("dict", IOUtils.normalizeLexiconName(clarkCluster.getName()));
            Element clarkWindow = new Element("window");
            clarkWindow.setAttribute("prevLength", Integer.toString(leftWindow));
            clarkWindow.setAttribute("nextLength", Integer.toString(rightWindow));
            clarkWindow.addContent(clarkFeatures);
            generators.addContent(clarkWindow);
        }
        System.err.println("-> Clark Cluster Features added!");
    }
    //word2vec clustering features
    if (Flags.isWord2VecClusterFeatures(params)) {
        setWindow(params);
        String word2vecClusterPath = Flags.getWord2VecClusterFeatures(params);
        List<File> word2vecClusterFiles = Flags.getClusterLexiconFiles(word2vecClusterPath);
        for (File word2vecFile : word2vecClusterFiles) {
            Element word2vecClusterFeatures = new Element("custom");
            word2vecClusterFeatures.setAttribute("class", Word2VecClusterFeatureGenerator.class.getName());
            word2vecClusterFeatures.setAttribute("dict", IOUtils.normalizeLexiconName(word2vecFile.getName()));
            Element word2vecClusterWindow = new Element("window");
            word2vecClusterWindow.setAttribute("prevLength", Integer.toString(leftWindow));
            word2vecClusterWindow.setAttribute("nextLength", Integer.toString(rightWindow));
            word2vecClusterWindow.addContent(word2vecClusterFeatures);
            generators.addContent(word2vecClusterWindow);
        }
        System.err.println("-> Word2Vec Clusters Features added!");
    }
    //Morphological features
    if (Flags.isPOSTagModelFeatures(params)) {
        setWindow(params);
        String posModelPath = Flags.getPOSTagModelFeatures(params);
        String posModelRange = Flags.getPOSTagModelFeaturesRange(params);
        Element posTagClassFeatureElement = new Element("custom");
        posTagClassFeatureElement.setAttribute("class", POSTagModelFeatureGenerator.class.getName());
        posTagClassFeatureElement.setAttribute("model",
                IOUtils.normalizeLexiconName(new File(posModelPath).getName()));
        posTagClassFeatureElement.setAttribute("range", posModelRange);
        Element posTagClassFeatureWindow = new Element("window");
        posTagClassFeatureWindow.setAttribute("prevLength", Integer.toString(leftWindow));
        posTagClassFeatureWindow.setAttribute("nextLength", Integer.toString(rightWindow));
        posTagClassFeatureWindow.addContent(posTagClassFeatureElement);
        generators.addContent(posTagClassFeatureWindow);
        System.err.println("-> POSTagModel Features added!");
    }
    if (Flags.isPOSDictionaryFeatures(params)) {
        setWindow(params);
        String posDictPath = Flags.getPOSDictionaryFeatures(params);
        Element posDictFeatures = new Element("custom");
        posDictFeatures.setAttribute("class", POSDictionaryFeatureGenerator.class.getName());
        posDictFeatures.setAttribute("dict", IOUtils.normalizeLexiconName(new File(posDictPath).getName()));
        Element posDictWindow = new Element("window");
        posDictWindow.setAttribute("prevLength", Integer.toString(leftWindow));
        posDictWindow.setAttribute("nextLength", Integer.toString(rightWindow));
        posDictWindow.addContent(posDictFeatures);
        generators.addContent(posDictWindow);
        System.err.println("-> POSDictionary Features added!");
    }
    if (Flags.isLemmaModelFeatures(params)) {
        setWindow(params);
        String lemmaModelPath = Flags.getLemmaModelFeatures(params);
        Element lemmaClassFeatureElement = new Element("custom");
        lemmaClassFeatureElement.setAttribute("class", LemmaModelFeatureGenerator.class.getName());
        lemmaClassFeatureElement.setAttribute("model",
                IOUtils.normalizeLexiconName(new File(lemmaModelPath).getName()));
        Element lemmaClassFeatureWindow = new Element("window");
        lemmaClassFeatureWindow.setAttribute("prevLength", Integer.toString(leftWindow));
        lemmaClassFeatureWindow.setAttribute("nextLength", Integer.toString(rightWindow));
        lemmaClassFeatureWindow.addContent(lemmaClassFeatureElement);
        generators.addContent(lemmaClassFeatureWindow);
        System.err.println("-> LemmaModel Features added!");
    }
    if (Flags.isLemmaDictionaryFeatures(params)) {
        setWindow(params);
        String lemmaDictPath = Flags.getLemmaDictionaryFeatures(params);
        String[] lemmaDictResources = Flags.getLemmaDictionaryResources(lemmaDictPath);
        Element lemmaClassFeatureElement = new Element("custom");
        lemmaClassFeatureElement.setAttribute("class", LemmaDictionaryFeatureGenerator.class.getName());
        lemmaClassFeatureElement.setAttribute("model",
                IOUtils.normalizeLexiconName(new File(lemmaDictResources[0]).getName()));
        lemmaClassFeatureElement.setAttribute("dict",
                IOUtils.normalizeLexiconName(new File(lemmaDictResources[1]).getName()));
        Element lemmaClassFeatureWindow = new Element("window");
        lemmaClassFeatureWindow.setAttribute("prevLength", Integer.toString(leftWindow));
        lemmaClassFeatureWindow.setAttribute("nextLength", Integer.toString(rightWindow));
        lemmaClassFeatureWindow.addContent(lemmaClassFeatureElement);
        generators.addContent(lemmaClassFeatureWindow);
        System.err.println("-> LemmaDictionary Features added!");
    }
    if (Flags.isMFSFeatures(params)) {
        setWindow(params);
        String mfsPath = Flags.getMFSFeatures(params);
        String[] mfsResources = Flags.getMFSResources(mfsPath);
        String mfsRange = Flags.getMFSFeaturesRange(params);
        String seqCodec = Flags.getSequenceCodec(params);
        Element mfsClassFeatureElement = new Element("custom");
        mfsClassFeatureElement.setAttribute("class", MFSFeatureGenerator.class.getName());
        mfsClassFeatureElement.setAttribute("model",
                IOUtils.normalizeLexiconName(new File(mfsResources[0]).getName()));
        mfsClassFeatureElement.setAttribute("dict",
                IOUtils.normalizeLexiconName(new File(mfsResources[1]).getName()));
        mfsClassFeatureElement.setAttribute("mfs",
                IOUtils.normalizeLexiconName(new File(mfsResources[2]).getName()));
        mfsClassFeatureElement.setAttribute("range", mfsRange);
        mfsClassFeatureElement.setAttribute("seqCodec", seqCodec);
        Element mfsClassFeatureWindow = new Element("window");
        mfsClassFeatureWindow.setAttribute("prevLength", Integer.toString(leftWindow));
        mfsClassFeatureWindow.setAttribute("nextLength", Integer.toString(rightWindow));
        mfsClassFeatureWindow.addContent(mfsClassFeatureElement);
        generators.addContent(mfsClassFeatureWindow);
        System.err.println("-> MFS Features added");
    }
    if (Flags.isSuperSenseFeatures(params)) {
        String mfsPath = Flags.getSuperSenseFeatures(params);
        String[] mfsResources = Flags.getSuperSenseResources(mfsPath);
        String mfsRange = Flags.getSuperSenseFeaturesRange(params);
        String seqCodec = Flags.getSequenceCodec(params);
        Element mfsClassFeatureElement = new Element("custom");
        mfsClassFeatureElement.setAttribute("class", SuperSenseFeatureGenerator.class.getName());
        mfsClassFeatureElement.setAttribute("model",
                IOUtils.normalizeLexiconName(new File(mfsResources[0]).getName()));
        mfsClassFeatureElement.setAttribute("dict",
                IOUtils.normalizeLexiconName(new File(mfsResources[1]).getName()));
        mfsClassFeatureElement.setAttribute("mfs",
                IOUtils.normalizeLexiconName(new File(mfsResources[2]).getName()));
        mfsClassFeatureElement.setAttribute("range", mfsRange);
        mfsClassFeatureElement.setAttribute("seqCodec", seqCodec);
        generators.addContent(mfsClassFeatureElement);
        System.err.println("-> SuperSense Features added!");
    }
    if (Flags.isPOSBaselineFeatures(params)) {
        String beginPrefix = Flags.getPrefixBegin(params);
        String endPrefix = Flags.getPrefixEnd(params);
        String beginSuffix = Flags.getSuffixBegin(params);
        String endSuffix = Flags.getSuffixEnd(params);
        Element posFeatureElement = new Element("custom");
        posFeatureElement.setAttribute("class", POSBaselineContextGenerator.class.getName());
        posFeatureElement.setAttribute("prefBegin", beginPrefix);
        posFeatureElement.setAttribute("prefEnd", endPrefix);
        posFeatureElement.setAttribute("sufBegin", beginSuffix);
        posFeatureElement.setAttribute("sufEnd", endSuffix);
        generators.addContent(posFeatureElement);
        System.err.println("-> POS Baseline Context Generator added!");
    }
    if (Flags.isLemmaBaselineFeatures(params)) {
        String beginPrefix = Flags.getPrefixBegin(params);
        String endPrefix = Flags.getPrefixEnd(params);
        String beginSuffix = Flags.getSuffixBegin(params);
        String endSuffix = Flags.getSuffixEnd(params);
        String posModel = Flags.getLemmaBaselineFeatures(params);
        String lemmaRange = Flags.getLemmaBaselineFeaturesRange(params);
        Element lemmaFeatureElement = new Element("custom");
        lemmaFeatureElement.setAttribute("class", LemmaBaselineContextGenerator.class.getName());
        lemmaFeatureElement.setAttribute("prefBegin", beginPrefix);
        lemmaFeatureElement.setAttribute("prefEnd", endPrefix);
        lemmaFeatureElement.setAttribute("sufBegin", beginSuffix);
        lemmaFeatureElement.setAttribute("sufEnd", endSuffix);
        lemmaFeatureElement.setAttribute("model", IOUtils.normalizeLexiconName(new File(posModel).getName()));
        lemmaFeatureElement.setAttribute("range", lemmaRange);
        generators.addContent(lemmaFeatureElement);
        System.err.println("-> Lemma Baseline Context Generator added!");
    }
    if (Flags.isChunkBaselineFeatures(params)) {
        String posModel = Flags.getChunkBaselineFeatures(params);
        Element chunkFeatureElement = new Element("custom");
        chunkFeatureElement.setAttribute("class", ChunkBaselineContextGenerator.class.getName());
        chunkFeatureElement.setAttribute("model", IOUtils.normalizeLexiconName(new File(posModel).getName()));
        generators.addContent(chunkFeatureElement);
        System.err.println("-> Chunk Baseline Context Generator added!");
    }

    if (Flags.isPredicateContextFeatures(params)) {
        String predicateContextFile = Flags.getPredicateContextFeatures(params);
        Element predicateContextFeatureElement = new Element("custom");
        predicateContextFeatureElement.setAttribute("class", PredicateContextFeatureGenerator.class.getName());
        predicateContextFeatureElement.setAttribute("dict",
                IOUtils.normalizeLexiconName(new File(predicateContextFile).getName()));
        generators.addContent(predicateContextFeatureElement);
        System.err.println("-> Predicate Context Generator added!");
    }

    aggGenerators.addContent(cached);
    cached.addContent(generators);

    XMLOutputter xmlOutput = new XMLOutputter();
    Format format = Format.getPrettyFormat();
    xmlOutput.setFormat(format);
    return xmlOutput.outputString(doc);

}

From source file:eus.ixa.ixa.pipe.nerc.features.XMLFeatureDescriptor.java

License:Apache License

/**
 * Generate the XML feature descriptor from the TrainingParameters prop file.
 * @param params the properties file//from  w w w  .  j  a v a 2  s. co  m
 * @return the XML feature descriptor
 * @throws IOException if input output fails
 */
public static String createXMLFeatureDescriptor(TrainingParameters params) throws IOException {

    Element aggGenerators = new Element("generators");
    Document doc = new Document(aggGenerators);

    //<generators>
    //  <cache>
    //    <generators>
    Element cached = new Element("cache");
    Element generators = new Element("generators");
    //<window prevLength="2" nextLength="2">
    //  <token />
    //</window>
    if (Flags.isTokenFeature(params)) {
        setWindow(params);
        Element tokenFeature = new Element("custom");
        tokenFeature.setAttribute("class", TokenFeatureGenerator.class.getName());
        Element tokenWindow = new Element("window");
        tokenWindow.setAttribute("prevLength", Integer.toString(leftWindow));
        tokenWindow.setAttribute("nextLength", Integer.toString(rightWindow));
        tokenWindow.addContent(tokenFeature);
        generators.addContent(tokenWindow);
        System.err.println("-> Token features added!: Window range " + leftWindow + ":" + rightWindow);
    }
    if (Flags.isTokenClassFeature(params)) {
        setWindow(params);
        Element tokenClassFeature = new Element("custom");
        tokenClassFeature.setAttribute("class", TokenClassFeatureGenerator.class.getName());
        Element tokenClassWindow = new Element("window");
        tokenClassWindow.setAttribute("prevLength", Integer.toString(leftWindow));
        tokenClassWindow.setAttribute("nextLength", Integer.toString(rightWindow));
        tokenClassWindow.addContent(tokenClassFeature);
        generators.addContent(tokenClassWindow);
        System.err.println("-> Token Class Features added!: Window range " + leftWindow + ":" + rightWindow);
    }
    if (Flags.isWordShapeSuperSenseFeature(params)) {
        setWindow(params);
        Element wordShapeSuperSenseFeature = new Element("custom");
        wordShapeSuperSenseFeature.setAttribute("class", WordShapeSuperSenseFeatureGenerator.class.getName());
        Element wordShapeWindow = new Element("window");
        wordShapeWindow.setAttribute("prevLength", Integer.toString(leftWindow));
        wordShapeWindow.setAttribute("nextLength", Integer.toString(rightWindow));
        wordShapeWindow.addContent(wordShapeSuperSenseFeature);
        generators.addContent(wordShapeWindow);
        System.err.println(
                "-> Word Shape SuperSense Features added!: Window range " + leftWindow + ":" + rightWindow);
    }
    if (Flags.isOutcomePriorFeature(params)) {
        Element outcomePriorFeature = new Element("custom");
        outcomePriorFeature.setAttribute("class", OutcomePriorFeatureGenerator.class.getName());
        generators.addContent(outcomePriorFeature);
        System.err.println("-> Outcome Prior Features added!");
    }
    if (Flags.isPreviousMapFeature(params)) {
        Element previousMapFeature = new Element("custom");
        previousMapFeature.setAttribute("class", PreviousMapFeatureGenerator.class.getName());
        generators.addContent(previousMapFeature);
        System.err.println("-> Previous Map Features added!");
    }
    if (Flags.isSentenceFeature(params)) {
        Element sentenceFeature = new Element("custom");
        sentenceFeature.setAttribute("class", SentenceFeatureGenerator.class.getName());
        sentenceFeature.setAttribute("begin", "true");
        sentenceFeature.setAttribute("end", "false");
        generators.addContent(sentenceFeature);
        System.err.println("-> Sentence Features added!");
    }
    if (Flags.isPrefixFeature(params)) {
        Element prefixFeature = new Element("custom");
        prefixFeature.setAttribute("class", Prefix34FeatureGenerator.class.getName());
        generators.addContent(prefixFeature);
        System.err.println("-> Prefix Features added!");
    }
    if (Flags.isSuffixFeature(params)) {
        Element suffixFeature = new Element("custom");
        suffixFeature.setAttribute("class", SuffixFeatureGenerator.class.getName());
        generators.addContent(suffixFeature);
        System.err.println("-> Suffix Features added!");
    }
    if (Flags.isBigramClassFeature(params)) {
        Element bigramFeature = new Element("custom");
        bigramFeature.setAttribute("class", BigramClassFeatureGenerator.class.getName());
        generators.addContent(bigramFeature);
        System.err.println("-> Bigram Class Features added!");
    }
    if (Flags.isTrigramClassFeature(params)) {
        Element trigramFeature = new Element("custom");
        trigramFeature.setAttribute("class", TrigramClassFeatureGenerator.class.getName());
        generators.addContent(trigramFeature);
        System.err.println("-> Trigram Class Features added!");
    }
    if (Flags.isFourgramClassFeature(params)) {
        Element fourgramFeature = new Element("custom");
        fourgramFeature.setAttribute("class", FourgramClassFeatureGenerator.class.getName());
        generators.addContent(fourgramFeature);
        System.err.println("-> Fourgram Class Features added!");
    }
    if (Flags.isFivegramClassFeature(params)) {
        Element fivegramFeature = new Element("custom");
        fivegramFeature.setAttribute("class", FivegramClassFeatureGenerator.class.getName());
        generators.addContent(fivegramFeature);
        System.err.println("-> Fivegram Class Features added!");
    }
    if (Flags.isCharNgramClassFeature(params)) {
        setNgramRange(params);
        Element charngramFeature = new Element("custom");
        charngramFeature.setAttribute("class", CharacterNgramFeatureGenerator.class.getName());
        charngramFeature.setAttribute("minLength", Integer.toString(minCharNgram));
        charngramFeature.setAttribute("maxLength", Integer.toString(maxCharNgram));
        generators.addContent(charngramFeature);
        System.err.println("-> CharNgram Class Features added!");
    }
    //Dictionary Features
    if (Flags.isDictionaryFeatures(params)) {
        setWindow(params);
        String dictPath = Flags.getDictionaryFeatures(params);
        String seqCodec = Flags.getSequenceCodec(params);
        List<File> fileList = StringUtils.getFilesInDir(new File(dictPath));
        for (File dictFile : fileList) {
            Element dictFeatures = new Element("custom");
            dictFeatures.setAttribute("class", DictionaryFeatureGenerator.class.getName());
            dictFeatures.setAttribute("dict", InputOutputUtils.normalizeLexiconName(dictFile.getName()));
            dictFeatures.setAttribute("seqCodec", seqCodec);
            Element dictWindow = new Element("window");
            dictWindow.setAttribute("prevLength", Integer.toString(leftWindow));
            dictWindow.setAttribute("nextLength", Integer.toString(rightWindow));
            dictWindow.addContent(dictFeatures);
            generators.addContent(dictWindow);
        }
        System.err.println("-> Dictionary Features added!");
    }
    //Brown clustering features
    if (Flags.isBrownFeatures(params)) {
        setWindow(params);
        //previous 2 maps features
        Element prev2MapFeature = new Element("custom");
        prev2MapFeature.setAttribute("class", Prev2MapFeatureGenerator.class.getName());
        generators.addContent(prev2MapFeature);
        //previous map and token feature (in window)
        Element prevMapTokenFeature = new Element("custom");
        prevMapTokenFeature.setAttribute("class", PreviousMapTokenFeatureGenerator.class.getName());
        Element prevMapTokenWindow = new Element("window");
        prevMapTokenWindow.setAttribute("prevLength", Integer.toString(leftWindow));
        prevMapTokenWindow.setAttribute("nextLength", Integer.toString(rightWindow));
        prevMapTokenWindow.addContent(prevMapTokenFeature);
        generators.addContent(prevMapTokenWindow);
        //brown clustering features
        String brownClusterPath = Flags.getBrownFeatures(params);
        List<File> brownClusterFiles = Flags.getClusterLexiconFiles(brownClusterPath);
        for (File brownClusterFile : brownClusterFiles) {
            //brown bigram class features
            Element brownBigramFeatures = new Element("custom");
            brownBigramFeatures.setAttribute("class", BrownBigramFeatureGenerator.class.getName());
            brownBigramFeatures.setAttribute("dict",
                    InputOutputUtils.normalizeLexiconName(brownClusterFile.getName()));
            generators.addContent(brownBigramFeatures);
            //brown token feature
            Element brownTokenFeature = new Element("custom");
            brownTokenFeature.setAttribute("class", BrownTokenFeatureGenerator.class.getName());
            brownTokenFeature.setAttribute("dict",
                    InputOutputUtils.normalizeLexiconName(brownClusterFile.getName()));
            Element brownTokenWindow = new Element("window");
            brownTokenWindow.setAttribute("prevLength", Integer.toString(leftWindow));
            brownTokenWindow.setAttribute("nextLength", Integer.toString(rightWindow));
            brownTokenWindow.addContent(brownTokenFeature);
            generators.addContent(brownTokenWindow);
            //brown token class feature
            Element brownTokenClassFeature = new Element("custom");
            brownTokenClassFeature.setAttribute("class", BrownTokenClassFeatureGenerator.class.getName());
            brownTokenClassFeature.setAttribute("dict",
                    InputOutputUtils.normalizeLexiconName(brownClusterFile.getName()));
            Element brownTokenClassWindow = new Element("window");
            brownTokenClassWindow.setAttribute("prevLength", Integer.toString(leftWindow));
            brownTokenClassWindow.setAttribute("nextLength", Integer.toString(rightWindow));
            brownTokenClassWindow.addContent(brownTokenClassFeature);
            generators.addContent(brownTokenClassWindow);
        }
        System.err.println("-> Brown Cluster Features added!");
    }
    //Clark clustering features
    if (Flags.isClarkFeatures(params)) {
        setWindow(params);
        String clarkClusterPath = Flags.getClarkFeatures(params);
        List<File> clarkClusterFiles = Flags.getClusterLexiconFiles(clarkClusterPath);
        for (File clarkCluster : clarkClusterFiles) {
            Element clarkFeatures = new Element("custom");
            clarkFeatures.setAttribute("class", ClarkFeatureGenerator.class.getName());
            clarkFeatures.setAttribute("dict", InputOutputUtils.normalizeLexiconName(clarkCluster.getName()));
            Element clarkWindow = new Element("window");
            clarkWindow.setAttribute("prevLength", Integer.toString(leftWindow));
            clarkWindow.setAttribute("nextLength", Integer.toString(rightWindow));
            clarkWindow.addContent(clarkFeatures);
            generators.addContent(clarkWindow);
        }
        System.err.println("-> Clark Cluster Features added!");
    }
    //word2vec clustering features
    if (Flags.isWord2VecClusterFeatures(params)) {
        setWindow(params);
        String word2vecClusterPath = Flags.getWord2VecClusterFeatures(params);
        List<File> word2vecClusterFiles = Flags.getClusterLexiconFiles(word2vecClusterPath);
        for (File word2vecFile : word2vecClusterFiles) {
            Element word2vecClusterFeatures = new Element("custom");
            word2vecClusterFeatures.setAttribute("class", Word2VecClusterFeatureGenerator.class.getName());
            word2vecClusterFeatures.setAttribute("dict",
                    InputOutputUtils.normalizeLexiconName(word2vecFile.getName()));
            Element word2vecClusterWindow = new Element("window");
            word2vecClusterWindow.setAttribute("prevLength", Integer.toString(leftWindow));
            word2vecClusterWindow.setAttribute("nextLength", Integer.toString(rightWindow));
            word2vecClusterWindow.addContent(word2vecClusterFeatures);
            generators.addContent(word2vecClusterWindow);
        }
        System.err.println("-> Word2Vec Clusters Features added!");
    }
    //Morphological features
    if (Flags.isMorphoFeatures(params)) {
        setWindow(params);
        String morphoPath = Flags.getMorphoFeatures(params);
        String[] morphoResources = Flags.getMorphoResources(morphoPath);
        String morphoRange = Flags.getMorphoFeaturesRange(params);
        Element morphoClassFeatureElement = new Element("custom");
        morphoClassFeatureElement.setAttribute("class", MorphoFeatureGenerator.class.getName());
        morphoClassFeatureElement.setAttribute("model",
                InputOutputUtils.normalizeLexiconName(new File(morphoResources[0]).getName()));
        morphoClassFeatureElement.setAttribute("dict",
                InputOutputUtils.normalizeLexiconName(new File(morphoResources[1]).getName()));
        morphoClassFeatureElement.setAttribute("range", morphoRange);
        Element morphoClassFeatureWindow = new Element("window");
        morphoClassFeatureWindow.setAttribute("prevLength", Integer.toString(leftWindow));
        morphoClassFeatureWindow.setAttribute("nextLength", Integer.toString(rightWindow));
        morphoClassFeatureWindow.addContent(morphoClassFeatureElement);
        generators.addContent(morphoClassFeatureWindow);
        System.err.println("-> Morphological Features added!");
    }
    if (Flags.isMFSFeatures(params)) {
        setWindow(params);
        String mfsPath = Flags.getMFSFeatures(params);
        String[] mfsResources = Flags.getMFSResources(mfsPath);
        String mfsRange = Flags.getMFSFeaturesRange(params);
        String seqCodec = Flags.getSequenceCodec(params);
        Element mfsClassFeatureElement = new Element("custom");
        mfsClassFeatureElement.setAttribute("class", MFSFeatureGenerator.class.getName());
        mfsClassFeatureElement.setAttribute("model",
                InputOutputUtils.normalizeLexiconName(new File(mfsResources[0]).getName()));
        mfsClassFeatureElement.setAttribute("dict",
                InputOutputUtils.normalizeLexiconName(new File(mfsResources[1]).getName()));
        mfsClassFeatureElement.setAttribute("mfs",
                InputOutputUtils.normalizeLexiconName(new File(mfsResources[2]).getName()));
        mfsClassFeatureElement.setAttribute("range", mfsRange);
        mfsClassFeatureElement.setAttribute("seqCodec", seqCodec);
        Element mfsClassFeatureWindow = new Element("window");
        mfsClassFeatureWindow.setAttribute("prevLength", Integer.toString(leftWindow));
        mfsClassFeatureWindow.setAttribute("nextLength", Integer.toString(rightWindow));
        mfsClassFeatureWindow.addContent(mfsClassFeatureElement);
        generators.addContent(mfsClassFeatureWindow);
        System.err.println("-> MFS Features added");
    }
    if (Flags.isSuperSenseFeatures(params)) {
        String mfsPath = Flags.getSuperSenseFeatures(params);
        String[] mfsResources = Flags.getSuperSenseResources(mfsPath);
        String mfsRange = Flags.getSuperSenseFeaturesRange(params);
        String seqCodec = Flags.getSequenceCodec(params);
        Element mfsClassFeatureElement = new Element("custom");
        mfsClassFeatureElement.setAttribute("class", SuperSenseFeatureGenerator.class.getName());
        mfsClassFeatureElement.setAttribute("model",
                InputOutputUtils.normalizeLexiconName(new File(mfsResources[0]).getName()));
        mfsClassFeatureElement.setAttribute("dict",
                InputOutputUtils.normalizeLexiconName(new File(mfsResources[1]).getName()));
        mfsClassFeatureElement.setAttribute("mfs",
                InputOutputUtils.normalizeLexiconName(new File(mfsResources[2]).getName()));
        mfsClassFeatureElement.setAttribute("range", mfsRange);
        mfsClassFeatureElement.setAttribute("seqCodec", seqCodec);
        generators.addContent(mfsClassFeatureElement);
        System.err.println("-> SuperSense Features added!");
    }

    aggGenerators.addContent(cached);
    cached.addContent(generators);

    XMLOutputter xmlOutput = new XMLOutputter();
    Format format = Format.getPrettyFormat();
    xmlOutput.setFormat(format);
    return xmlOutput.outputString(doc);

}

From source file:facturacion.controller.FacturaController.java

public void crearArchivo() {

    try {/*  ww w  .java  2 s  . c  o  m*/
        DOMBuilder builder = new DOMBuilder();
        org.jdom2.Document jdom = builder.build((new DOMOutputter()).output(facturaXml.getDoc()));
        XMLOutputter xmlOutput = new XMLOutputter();
        xmlOutput.setFormat(Format.getPrettyFormat());
        FileWriter a = new FileWriter("C:\\tributasoft\\prueba\\filePrueba" + this.factura.getPunto_emision()
                + this.factura.getNumero_factura() + ".xml");
        xmlOutput.output(jdom, a);
        a.close();
        facturaXml.getClaveAcceso();
        System.out.println("----> firmar factura +++ 16==" + facturaXml.getClaveAcceso());
    } catch (JDOMException e) {
        // TODO Auto-generated catch block
        System.out.println("----> firmar factura +++ 1");

        e.printStackTrace();

    } catch (NullPointerException e) {
        // TODO Auto-generated catch block
        System.out.println("----> firmar factura +++ 2");
        e.printStackTrace();

    } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }

}