Laboratoire ICAR » Plateforme TXM

// Copyright © 2016 ENS de Lyon, CNRS, University of Franche-Comté

// Licensed under the terms of the GNU General Public License (http://www.gnu.org/licenses)

// @author mdecorde

// @author sheiden

// STANDARD DECLARATIONS

package org.txm.macro.urs

import org.apache.commons.lang.StringUtils;

import org.kohsuke.args4j.*

import groovy.transform.Field

import org.txm.Toolbox;

import org.txm.rcp.swt.widget.parameters.*

import org.txm.annotation.urs.*

import org.txm.searchengine.cqp.AbstractCqiClient;

import org.txm.searchengine.cqp.corpus.*

import visuAnalec.Message.StructureEvent;

import visuAnalec.Message.TypeModifStructure;

import visuAnalec.donnees.Structure;

import visuAnalec.elements.Unite;

import visuAnalec.vue.Vue

if (!(corpusViewSelection instanceof MainCorpus)) {

	println "Corpora selection is not a Corpus"

	return;

}

// BEGINNING OF PARAMETERS

@Field @Option(name="unit_type",usage="", widget="String", required=true, def="Maillon")

String unit_type

@Field @Option(name="reset",usage="", widget="Boolean", required=true, def="true")

boolean reset

if (!ParametersDialog.open(this)) return;

MainCorpus corpus = corpusViewSelection

AbstractCqiClient CQI = CQPSearchEngine.getCqiClient();

def word = corpus.getWordProperty()

def analecCorpus = URSCorpora.getCorpus(corpus);

Structure structure = analecCorpus.getStructure()

if (!structure.getUnites().contains(unit_type)) { // check if the structure contains the unit_type units

	println "Error: corpus structure does not contains unit with name=$unit_type"

	return

}

def props = structure.getUniteProperties(unit_type)

String DEFINITUDE = "DEFINITUDE"

if (!props.contains(DEFINITUDE)) { // update the structure if needed

	analecCorpus.ajouterProp(Unite.class, unit_type, DEFINITUDE);

	analecCorpus.ajouterVal(Unite.class, unit_type, DEFINITUDE, "DEFINI");

	analecCorpus.ajouterVal(Unite.class, unit_type, DEFINITUDE, "INDEFINI");

	analecCorpus.ajouterVal(Unite.class, unit_type, DEFINITUDE, "DEMONSTRATIF");

	analecCorpus.ajouterVal(Unite.class, unit_type, DEFINITUDE, "AMBIGU");

	analecCorpus.ajouterVal(Unite.class, unit_type, DEFINITUDE, "NONE");

}

int nIgnored = 0 // number of ignored units

int nModified = 0 // number of modified units

int nDefini = 0 // number of "DEFINI" units

int nIndefini = 0 // number of "InDEFINI" units

int nDemonstratif = 0 // number of "DEMONSTRATIF" units

int nAmbigu = 0 // number of "AMBIGU" units

int nNone = 0 // number of "NONE" units

def units = analecCorpus.getUnites(unit_type)

units.sort() { a, b -> a.getDeb() <=> b.getDeb() ?: a.getFin() <=> b.getFin() }

for (Unite unit : units) { // process all units

	def prop = unit.getProp(DEFINITUDE);

	int[] pos = null

	if (unit.getDeb() == unit.getFin()) pos = [unit.getDeb()]

	else pos = (unit.getDeb()..unit.getFin())

	def form = StringUtils.join(CQI.cpos2Str(word.getQualifiedName(), pos), " ")

	if (reset || prop == null || prop.length() == 0 || prop.equals("NONE")) {

		// petits ajouts à faire ? : |(ses\s.+)|(Ses\s.+)|(son\s.+)|(Son\s.+)|(sa\s.+)|(Sa\s.+)|(leurs?\s.+)|(Leurs?\s.+)|(tous\s.+)|(Tous\s.+)|(toutes\s.+)|(Toutes\s.+)

		if (form =~ /^(le\s.+)|(Les\s.+)|(Le\s.+)|(la\s.+)|(La\s.+)|(l'.+)|(L'.+)|(les\s.+)|(au\s.+)|(Au\s.+)|(aux\s.+)|(Aux\s.+)|(du\s.+)|(Du\s.+)/) {

			unit.getProps().put(DEFINITUDE, "DEFINI")

			nDefini++

		} else if (form =~ /^(un\s.+)|(une\s.+)|(Un\s.+)|(Une\s.+)|(Chaque\s.+)|(chaque\s.+)|(Certains\s.+)|(Certaines\s.+)|(certains\s.+)|(certaines\s.+)|(aucun\s.+)|(aucune\s.+)|(Aucun\s.+)|(Aucunes\s.+)|(Autre\s.+)|(Autre\s.+)|(autres\s.+)|(autre\s.+)|(quelque\s.+)|(quelques\s.+)|(Quelque\s.+)|(Quelques\s.+)/) {

			unit.getProps().put(DEFINITUDE, "INDEFINI")

			nIndefini++

		} else if (form =~ /^(ce\s.+)|(cette\s.+)|(Cette\s.+)|(cet\s.+)|(ces\s.+)|(Ce\s.+)|(Cet\s.+)|(Ces\s.+)/) {

			unit.getProps().put(DEFINITUDE, "DEMONSTRATIF")

			nDemonstratif++

		} else if (form =~ /^(des\s.+)|(de\s.+)|(Des\s.+)|(De\s.+)/) {

			unit.getProps().put(DEFINITUDE, "AMBIGU")

			nAmbigu++

		} else {

			unit.getProps().put(DEFINITUDE, "NONE")

			nNone++;

		}

		nModified++

	} else {

		// nothing to do

		nIgnored++

	}

}

println "nIgnored=$nIgnored"

println "nModified=$nModified"

println " nDefini=$nDefini"

println " nIndefini=$nIndefini"

println " nDemonstratif=$nDemonstratif"

println " nAmbigu=$nAmbigu"

println " nNone=$nNone"

// Copyright © 2016 ENS de Lyon, CNRS, University of Franche-Comté

// Licensed under the terms of the GNU General Public License (http://www.gnu.org/licenses)

// @author mdecorde

// STANDARD DECLARATIONS

package org.txm.macro.urs

import org.kohsuke.args4j.*

import groovy.transform.Field

import org.txm.rcp.swt.widget.parameters.*

import org.txm.annotation.urs.*

import org.txm.searchengine.cqp.corpus.*

import visuAnalec.donnees.Structure;

import visuAnalec.elements.Relation;

import visuAnalec.elements.Schema

import visuAnalec.elements.Unite;

import visuAnalec.vue.Vue

if (!(corpusViewSelection instanceof MainCorpus)) {

	println "Corpora selection is not a Corpus"

	return;

}

// BEGINNING OF PARAMETERS

@Field @Option(name="unit_type",usage="", widget="String", required=true, def="MENTION")

		String unit_type

@Field @Option(name="schema_type",usage="", widget="String", required=true, def="CHAINE")

		String schema_type

if (!ParametersDialog.open(this)) return;

int nCreated = 0 // count the number of created RELATION

MainCorpus corpus = corpusViewSelection

def analecCorpus = URSCorpora.getCorpus(corpus); // analec corpus has the same name has the TXM corpus

Structure structure = analecCorpus.getStructure()

if (!structure.getUnites().contains(unit_type)) { // check if the structure contains the unit_type units

	println "Error: corpus structure does not contains unit with name=$unit_type"

	return

}

if (!structure.getSchemas().contains(schema_type)) { // check if the structure contains the unit_type units

	println "Error: corpus structure does not contains schema with name=$schema_type"

	return

}

if (!structure.getRelations().contains("ANAPHORE")) { // update the structure if needed

	println "Creating the 'ANAPHORE' relation in the structure"

	structure.ajouterType(Relation.class, "ANAPHORE")

	analecCorpus.ajouterProp(Relation.class, "ANAPHORE", "TYPE")

	analecCorpus.ajouterVal(Relation.class, "ANAPHORE", "TYPE", "COREFERENTE")

	analecCorpus.ajouterVal(Relation.class, "ANAPHORE", "TYPE", "ASSOCIATIVE")

}

if (analecCorpus.getRelations("ANAPHORE").size() > 0) {

	println "Error: This macro can't update existing Relations"

	return

}

for (Schema schema : analecCorpus.getSchemas(schema_type)) { // parse all CHAINE

	def units = []

	for (Unite unit : schema.getUnitesSousjacentes()) { // keep only the 'unit_type' units

		if (unit.type.equals(unit_type)) units << unit

	}

	units.sort() { a, b -> a.getDeb() <=> b.getDeb() ?: a.getFin() <=> b.getFin() } // sort them

	for (int i = 0 ; i < units.size() - 1 ; i++) { // build RELATIONS and don't process the last unit

		println "creating "+units[i+1]+", "+units[i]

		Relation relation = new Relation("ANAPHORE", units[i+1], units[i])

		relation.getProps().put("TYPE", "COREFERENTE")

		analecCorpus.addRelationLue(relation)  // add the new relation

		nCreated++;

	}

}

println "nCreated=$nCreated"

// Copyright © 2016 ENS de Lyon, CNRS, University of Franche-Comté

// Licensed under the terms of the GNU General Public License (http://www.gnu.org/licenses)

// @author mdecorde

// @author sheiden

// STANDARD DECLARATIONS

package org.txm.macro.urs

import org.kohsuke.args4j.*

import groovy.transform.Field

import org.txm.rcp.swt.widget.parameters.*

import org.txm.annotation.urs.*

import org.txm.searchengine.cqp.corpus.*

if (!(corpusViewSelection instanceof MainCorpus)) {

	println "Corpora selection is not a Corpus"

	return;

}

MainCorpus corpus = corpusViewSelection

def analecCorpus = URSCorpora.getCorpus(corpus);

def schemas = analecCorpus.getTousSchemas()

def set = new HashMap()

for (def s : schemas.collect { it.getType() }) {

	if (!set.containsKey(s)) set[s] = 0;

	set[s] = set[s] +1

}

println "Schemas types: "+set.sort() { it -> set[it]}

// Copyright © 2016 ENS de Lyon, CNRS, University of Franche-Comté

// Licensed under the terms of the GNU General Public License (http://www.gnu.org/licenses)

// @author mdecorde

// @author sheiden

// STANDARD DECLARATIONS

package org.txm.macro.urs

import org.kohsuke.args4j.*

import groovy.transform.Field

import org.txm.rcp.swt.widget.parameters.*

import org.txm.annotation.urs.*

import org.txm.searchengine.cqp.corpus.*

// BEGINNING OF PARAMETERS

@Field @Option(name="schema_type",usage="", widget="String", required=true, def="Coréférence")

String schema_type

@Field @Option(name="minimum_schema_size",usage="", widget="Integer", required=true, def="3")

int minimum_schema_size

@Field @Option(name="schema_property_name",usage="", widget="String", required=false, def="")

String schema_property_name

@Field @Option(name="schema_property_value",usage="", widget="String", required=false, def=".*")

String schema_property_value

@Field @Option(name="unit_type",usage="", widget="String", required=false, def="Maillon")

String unit_type

@Field @Option(name="unit_property_name", usage="", widget="String", required=false, def="")

String unit_property_name

@Field @Option(name="unit_property_value", usage="", widget="String", required=false, def=".*")

String unit_property_value

if (!(corpusViewSelection instanceof MainCorpus)) {

	println "Corpora selection is not a Corpus"

	return;

}

// Open the parameters input dialog box

if (!ParametersDialog.open(this)) return;

// END OF PARAMETERS

MainCorpus corpus = corpusViewSelection

def analecCorpus = URSCorpora.getCorpus(corpus)

// check Schema parameters

if (!analecCorpus.getStructure().getSchemas().contains(schema_type)) {

	println "No schema with name=$schema_type"

	return;

} else {

	if (schema_property_name.length() > 0 && schema_property_value.length() > 0) {

		// test property existance

		def props = analecCorpus.getStructure().getSchemaProperties(schema_type);

		if (!props.contains(schema_property_name)) {

			println "Schema $schema_type has no property named $schema_property_name"

			return;

		}

	}

}

// check unit parameters

if (!analecCorpus.getStructure().getUnites().contains(unit_type)) {

	println "No unit with name=$unit_type"

	return;

} else {

	if (unit_property_name.length() > 0 && unit_property_value.length() > 0) {

		// test property existance

		def props = analecCorpus.getStructure().getUniteProperties(unit_type);

		if (!props.contains(unit_property_name)) {

			println "Unit $unit_type has no property named $unit_property_name"

			return;

		}

	}

}

def schemas = analecCorpus.getSchemas(schema_type)

int nSchemas = 0;

for (def schema : schemas) {

	if (schema_property_name.length() > 0 && schema_property_value.length() > 0) {

		if (!schema.getProp(schema_property_name).matches(schema_property_value)) {

			// ignoring this schema

			continue

		}

	}

	int nUnites = 0;

	for (def unit : schema.getUnitesSousjacentesNonTriees()) {

	if (unit_type.length() > 0) {

			if (!unit.getType().equals(unit_type)) {

				continue

			}

		}

		if (unit_property_name.length() > 0 && unit_property_value.length() > 0) {

			if (!unit.getProp(unit_property_name).matches(unit_property_value)) {

				// ignoring this schema

				continue

			}

		}

		nUnites++

	}

	if (nUnites < minimum_schema_size) continue;

	nSchemas++;

}

println "nombre de chaînes de référence d'un texte : $nSchemas"

["result":nSchemas, "data":schemas]

// Copyright © 2016 ENS de Lyon, CNRS, University of Franche-Comté

// Licensed under the terms of the GNU General Public License (http://www.gnu.org/licenses)

// @author mdecorde

// @author sheiden

// STANDARD DECLARATIONS

package org.txm.macro.urs

import org.kohsuke.args4j.*

import groovy.transform.Field

import org.txm.*

import org.txm.rcp.swt.widget.parameters.*

import org.txm.annotation.urs.*

import org.txm.searchengine.cqp.corpus.*

import org.apache.commons.lang.StringUtils;

// BEGINNING OF PARAMETERS

@Field @Option(name="schema_type",usage="", widget="String", required=true, def="Coréférence")

String schema_type

@Field @Option(name="minimum_schema_size", usage="", widget="Integer", required=true, def="3")

int minimum_schema_size

@Field @Option(name="schema_property_name",usage="", widget="String", required=false, def="")

String schema_property_name

@Field @Option(name="schema_property_value",usage="", widget="String", required=false, def=".*")

String schema_property_value

@Field @Option(name="unit_type",usage="", widget="String", required=false, def="Maillon")

String unit_type

@Field @Option(name="unit_property_name", usage="", widget="String", required=false, def="")

String unit_property_name

@Field @Option(name="unit_property_value", usage="", widget="String", required=false, def=".*")

String unit_property_value

if (!(corpusViewSelection instanceof MainCorpus)) {

	println "Corpora selection is not a Corpus"

	return;

}

if (!ParametersDialog.open(this)) return;

MainCorpus corpus = corpusViewSelection

def analecCorpus = URSCorpora.getCorpus(corpus)

// check Schema parameters

if (!analecCorpus.getStructure().getSchemas().contains(schema_type)) {

	println "No schema with name=$schema_type"

	return;

} else {

	if (schema_property_name.length() > 0 && schema_property_value.length() > 0) {

		// test property existance

		def props = analecCorpus.getStructure().getSchemaProperties(schema_type);

		if (!props.contains(schema_property_name)) {

			println "Schema $schema_type has no property named $schema_property_name"

			return;

		}

	}

}

// check unit parameters

if (!analecCorpus.getStructure().getUnites().contains(unit_type)) {

	println "No unit with name=$unit_type"

	return;

} else {

	if (unit_property_name.length() > 0 && unit_property_value.length() > 0) {

		// test property existance

		def props = analecCorpus.getStructure().getUniteProperties(unit_type);

		if (!props.contains(unit_property_name)) {

			println "Unit $unit_type has no property named $unit_property_name"

			return;

		}

	}

}

def schemas = analecCorpus.getSchemas(schema_type)

def distances = 0;

def nDistances = 0

for (def schema : schemas) {

	if (schema_property_name.length() > 0 && schema_property_value.length() > 0) {

		if (!schema.getProp(schema_property_name).matches(schema_property_value)) {

			// ignoring this schema

			continue

		}

	}

	def allUnites = schema.getUnitesSousjacentesNonTriees()

	int nUnites = allUnites.size()

	if (nUnites < minimum_schema_size) continue;

	def units = []

	for (def unit : allUnites) {

		if (unit_type.length() > 0) {

			if (!unit.getType().equals(unit_type)) {

				continue

			}

		}

		if (unit_property_name.length() > 0 && unit_property_value.length() > 0) {

			if (!unit.getProp(unit_property_name).matches(unit_property_value)) {

				// ignoring this schema

				continue

			}

		}

		units << unit

	}

	units.sort() { u1, u2 -> u1.getDeb() <=> u2.getDeb()}

	for (int i = 0 ; i < units.size() -1 ; i++) {

		distances +=  units[i+1].getDeb() - units[i].getFin() 

		nDistances++

	}

}

coef = (distances / nDistances)

println "distance moyenne inter-mayonnaise : $distances / $nDistances = $coef"

return ["result":coef, "data":["distances":distances, "nDistances":nDistances]]

// Copyright © 2016 ENS de Lyon, CNRS, University of Franche-Comté

// Licensed under the terms of the GNU General Public License (http://www.gnu.org/licenses)

// @author mdecorde

// @author sheiden

// STANDARD DECLARATIONS

package org.txm.macro.urs

import org.kohsuke.args4j.*

import groovy.transform.Field

import org.txm.*

import org.txm.rcp.swt.widget.parameters.*

import org.txm.annotation.urs.*

import org.txm.searchengine.cqp.corpus.*

import org.apache.commons.lang.StringUtils;

// BEGINNING OF PARAMETERS

@Field @Option(name="schema_type",usage="", widget="String", required=true, def="Coréférence")

String schema_type

@Field @Option(name="minimum_schema_size", usage="", widget="Integer", required=true, def="3")

int minimum_schema_size

@Field @Option(name="schema_property_name",usage="", widget="String", required=false, def="")

String schema_property_name

@Field @Option(name="schema_property_value",usage="", widget="String", required=false, def=".*")

String schema_property_value

@Field @Option(name="unit_type",usage="", widget="String", required=false, def="Maillon")

String unit_type

@Field @Option(name="unit_property_name", usage="", widget="String", required=false, def="")

String unit_property_name

@Field @Option(name="unit_property_value", usage="", widget="String", required=false, def=".*")

String unit_property_value

@Field @Option(name="word_property", usage="", widget="StringArray", metaVar="Catégorie	pos	fropos	frpos", required=false, def="Catégorie")

String word_property

if (!(corpusViewSelection instanceof MainCorpus)) {

	println "Corpora selection is not a Corpus"

	return;

}

// Open the parameters input dialog box

if (!ParametersDialog.open(this)) return;

// END OF PARAMETERS

MainCorpus corpus = corpusViewSelection

def analecCorpus = URSCorpora.getCorpus(corpus)

if (!analecCorpus.getStructure().getSchemas().contains(schema_type)) {

	println "No schema with name=$schema_type"

	return;

} else {

	if (schema_property_name.length() > 0 && schema_property_value.length() > 0) {

		// test property existance

		def props = analecCorpus.getStructure().getSchemaProperties(schema_type);

		if (!props.contains(schema_property_name)) {

			println "Schema $schema_type has no property named $schema_property_name"

			return;

		}

	}

}

if (!analecCorpus.getStructure().getUnites().contains(unit_type)) {

	println "No unit with name=$unit_type"

	return;

} else {

	if (unit_property_name.length() > 0 && unit_property_value.length() > 0) {

		// test property existance

		def props = analecCorpus.getStructure().getUniteProperties(unit_type);

		if (!props.contains(unit_property_name)) {

			println "Unit $unit_type has no property named $unit_property_name"

			return;

		}

	}

}

def CQI = CQPSearchEngine.getCqiClient()

def prop = corpus.getProperty(word_property)

def schemas = analecCorpus.getSchemas(schema_type)

def freqs = [:]

def distances = 0;

def nDistances = 0

for (def schema : schemas) {

	if (schema_property_name.length() > 0 && schema_property_value.length() > 0) {

		if (!schema.getProp(schema_property_name).matches(schema_property_value)) {

			// ignoring this schema

			continue

		}

	}

	def allUnites = schema.getUnitesSousjacentesNonTriees()

	int nUnites = allUnites.size()

	if (nUnites < minimum_schema_size) continue;

	def units = []

	for (def unit : allUnites) {

		if (unit_type.length() > 0) {

			if (!unit.getType().equals(unit_type)) {

				continue

			}

		}

		if (unit_property_name.length() > 0 && unit_property_value.length() > 0) {

			if (!unit.getProp(unit_property_name).matches(unit_property_value)) {

				// ignoring this schema

				continue

			}

		}

		units << unit

	}

	units.sort() { u1, u2 ->

		return u1.getDeb() - u2.getDeb()

	}

	if (units.size() == 0) continue;

	def unit = units[0]

	String forme =  null;

	if (prop == null) { // word_property is the analec unit property to use

		forme = unit.getProp(word_property)

	} else {

		int[] pos = null;

		if (unit.getDeb() == unit.getFin()) pos = [unit.getDeb()]

		else pos = unit.getDeb()..unit.getFin()

		forme = StringUtils.join(CQI.cpos2Str(prop.getQualifiedName(), pos), " ") // ids is enough

	}

	if (!freqs.containsKey(forme)) freqs[forme] = 0;

	freqs[forme] = freqs[forme] + 1;

}

println "index des natures de premier maillon :"

int max = 0;

def result = "";

for (def forme : freqs.keySet().sort() {it -> -freqs[it]}) {

	println "$forme\t"+freqs[forme]

	if (max < freqs[forme]) {

		max = freqs[forme]

		result = "$forme: "+freqs[forme]

	}

}

["result": result, "data": freqs]

// Copyright © 2016 ENS de Lyon, CNRS, University of Franche-Comté

// Licensed under the terms of the GNU General Public License (http://www.gnu.org/licenses)

// @author mdecorde

// @author sheiden

// STANDARD DECLARATIONS

package org.txm.macro.urs

import org.kohsuke.args4j.*

import groovy.transform.Field

import org.txm.rcp.swt.widget.parameters.*

import org.txm.annotation.urs.*

import org.txm.searchengine.cqp.corpus.*

import org.txm.statsengine.r.core.RWorkspace;

import org.txm.Toolbox

import org.txm.rcp.commands.*

// BEGINNING OF PARAMETERS

@Field @Option(name="schema_type",usage="", widget="String", required=true, def="Coréférence")

String schema_type

@Field @Option(name="minimum_schema_size",usage="", widget="Integer", required=true, def="3")

int minimum_schema_size

@Field @Option(name="schema_property_name",usage="", widget="String", required=false, def="")

String schema_property_name

@Field @Option(name="schema_property_value",usage="", widget="String", required=false, def=".*")

String schema_property_value

@Field @Option(name="unit_type",usage="", widget="String", required=false, def="Maillon")

String unit_type

@Field @Option(name="unit_property_name", usage="", widget="String", required=false, def="")

String unit_property_name

@Field @Option(name="unit_property_value", usage="", widget="String", required=false, def=".*")

String unit_property_value

if (!(corpusViewSelection instanceof MainCorpus)) {

	println "Corpora selection is not a Corpus"

	return;

}

if (!ParametersDialog.open(this)) return;

// END OF PARAMETERS

MainCorpus corpus = corpusViewSelection

def analecCorpus = URSCorpora.getCorpus(corpus)

// check Schema parameters

if (!analecCorpus.getStructure().getSchemas().contains(schema_type)) {

	println "No schema with name=$schema_type"

	return;

} else {

	if (schema_property_name.length() > 0 && schema_property_value.length() > 0) {

		// test property existance

		def props = analecCorpus.getStructure().getSchemaProperties(schema_type);

		if (!props.contains(schema_property_name)) {

			println "Schema $schema_type has no property named $schema_property_name"

			return;

		}

	}

}

// check unit parameters

if (!analecCorpus.getStructure().getUnites().contains(unit_type)) {

	println "No unit with name=$unit_type"

	return;

} else {

	if (unit_property_name.length() > 0 && unit_property_value.length() > 0) {

		// test property existance

		def props = analecCorpus.getStructure().getUniteProperties(unit_type);

		if (!props.contains(unit_property_name)) {

			println "Unit $unit_type has no property named $unit_property_name"

			return;

		}

	}

}

def schemas = analecCorpus.getSchemas(schema_type)

int nSchemas = 0;

def lens = [:]

for (def schema : schemas) {

	if (schema_property_name.length() > 0 && schema_property_value.length() > 0) {

		if (!schema.getProp(schema_property_name).matches(schema_property_value)) {

			// ignoring this schema

			continue

		}

	}

	int nUnites = 0;

	for (def unit : schema.getUnitesSousjacentesNonTriees()) {

		if (unit_type.length() > 0) {

			if (!unit.getType().equals(unit_type)) {

				continue

			}

		}

		if (unit_property_name.length() > 0 && unit_property_value.length() > 0) {

			if (!unit.getProp(unit_property_name).matches(unit_property_value)) {

				// ignoring this schema

				continue

			}

		}

		nUnites++

	}

	if (nUnites < minimum_schema_size) continue;

	if (!lens.containsKey(nUnites)) lens[nUnites] = 0;

	lens[nUnites] = lens[nUnites] + 1;

	nSchemas++;

}

//println "nSchemas=$nSchemas"

def freqs = lens.keySet();

freqs.sort();

int t = 0;

int n = 0;

//println "Fréquences ("+freqs.size()+")"

for (def f : freqs) {

	t += f * lens[f]

	n += lens[f]

}

coef = (t/n)

def slens = lens.sort { a, b -> -a.value <=> -b.value ?: -a.key <=> -b.key }

def flens = []

slens.each { key, value -> value.times { flens << key } }

def nbins = flens.size()*2

def cfreq = 0

println "longueur moyenne des chaînes de référence : $t/$n = "+coef

println "index hiérarchique des longueurs de chaînes :\nlen\tfreq\tcfreq"

slens.each { println it.key+"	"+it.value+"	"+(cfreq+=it.value) }

def slens2 = slens.sort { a, b -> -a.key <=> -b.key }

def r = RWorkspace.getRWorkspaceInstance()

r.addVectorToWorkspace("len", slens2.keySet() as int[])

r.addVectorToWorkspace("freq", slens2.values() as int[])

r.addVectorToWorkspace("flen", flens as int[])

def corpusName = corpus.getName()

def file = File.createTempFile("txm", ".svg", new File(Toolbox.getTxmHomePath(), "results"))

println "SVG file: "+file.getAbsolutePath()

/// BEGINNING OF R SCRIPT

def script ="""

hist(flen, xaxt='n', col="gray", xlab="Length", breaks=$nbins, main="$corpusName Longueur des chaînes ($nbins bins)")

axis(side=1, at=len)

"""

/// END OF R SCRIPT

// execute R script

r.plot(file, script)

//display the SVG results graphic

monitor.syncExec(new Runnable() {

	@Override

	public void run() { OpenSVGGraph.OpenSVGFile(file.getAbsolutePath(), corpusName+" Longueur des chaînes") }

})

return ["result":coef, "data":lens]

// Copyright © 2016 ENS de Lyon, CNRS, University of Franche-Comté

// Licensed under the terms of the GNU General Public License (http://www.gnu.org/licenses)

// @author mdecorde

// @author sheiden

// STANDARD DECLARATIONS

package org.txm.macro.urs

import org.kohsuke.args4j.*

import groovy.transform.Field

import org.txm.rcp.swt.widget.parameters.*

import org.txm.annotation.urs.*

import org.txm.searchengine.cqp.corpus.*

if (!(corpusViewSelection instanceof MainCorpus)) {

	println "Corpora selection is not a Corpus"

	return;

}

// BEGINNING OF PARAMETERS

@Field @Option(name="schema_type",usage="", widget="String", required=true, def="Coréférence")

String schema_type

if (!ParametersDialog.open(this)) return;

MainCorpus corpus = corpusViewSelection

def analecCorpus = URSCorpora.getCorpus(corpus);

def unitesInSchema = new HashSet()

for (def schema : analecCorpus.getSchemas(schema_type)) {

	unitesInSchema.addAll(schema.getUnitesSousjacentes())

}

println "unites: "+analecCorpus.getToutesUnites().size()

println "unites in schema: "+unitesInSchema.size()

def set = new HashMap()

for (def u : analecCorpus.getToutesUnites()) {

	if (unitesInSchema.contains(u)) continue;

	if (!set.containsKey(u.getType())) set[u.getType()] = 0;

	set[u.getType()] = set[u.getType()] +1

}

println "unites not in schema: "+set.sort() { it -> set[it]}

// @author Bruno Oberlé (2017-04-01 21:50)

/*

Définit la catégorie grammaticale du maillon d'après le champ `frpos'

(tagset de TreeTagger).  Le script est adapté de

http://svn.code.sf.net/p/txm/code/trunk/plugins/Analec/AnalecRCP/src/org/txm/macro/analec/Fropos2CategorieMacro.groovy.

Voici la liste des catégories grammaticales retenues (manuel d'annotation de

Democrat):

- GN: Groupe Nominal (le petit chat, le chat, le même, ce chat etc.)

- POSS: Possessif (mon, ton son, ma, ta, sa, mes, tes, ses, notre, votre,

  leur, nos, vos, leurs)

- PR: Pronom (moi, toi, lui, elle, nous, vous, eux, elles, le tien, le mien,

  moi-même etc.)

- PR_CL_O: Pronom Clitique Objet (me, te, le, la, les, lui, leur, y, en)

- PR_CL_R: Pronom Clitique Réfléchi

- PR_CL_S: Pronom Clitique Sujet (je, tu, il, elle, on, nous, vous, ils,

  elles)

- PR_REL: Pronom Relatif (qui, que, quoi, dont, où, lequel, quiconque etc.)

- PR_WH: Pronom Interrogatif (qui, que, quoi, lequel etc.)

Le script ne peut pas désambiguïser les pronoms clitiques de même forme

(`nous' est-il un sujet, un objet ou un réfléchi?).  Dans ce cas, le script

opte pour le sujet (ou pour l'objet si l'ambiguïté n'est que entre objet et

réfléchi).

Quand il n'y a aucune information disponible (erreurs de l'étiqueteur), la

valeur est UNDEFINED.

L'algorithme est décrit ici:

https://groupes.renater.fr/wiki/democrat/prive/txm_annotation_exploitation

*/

package org.txm.macro.urs

import org.apache.commons.lang.*

import org.kohsuke.args4j.*

import groovy.transform.*

import org.txm.*

import org.txm.rcp.swt.widget.parameters.*

import org.txm.annotation.urs.*

import org.txm.searchengine.cqp.*

import org.txm.searchengine.cqp.corpus.*

import visuAnalec.Message.*

import visuAnalec.donnees.*

import visuAnalec.elements.*

import visuAnalec.vue.*

def testClitic(def position, def frpos) {

   // je me sers de la forme, parce qu'il est difficile de savoir quel est le

   // lemme de "elle" ("il"?), de "te" ("tu"?) ou encore de "leur"

   def form = CQI.cpos2Str(word.getQualifiedName(), position)[0].toLowerCase()

   if (     form == "je" || form == "j'"

         || form == "tu" || form == "t'"

         || form == "il"

         || form == "elle"

         || form == "on"

         || form == "vous"

         || form == "nous"

         || form == "ils"

         || form == "elles" ) {

      return "PR_CL_S"

   } else if (form == "me" || form == "m'"

           || form == "te"

           || form == "le" || form == "l'"

           || form == "la"

           || form == "lui"

           || form == "leur"

           || form == "les" ) {

      return "PR_CL_O"

   } else if (form == "se" || form == "s'") {

      return "PR_CL_R"

   }

   return null

}

def testPhrase(def positions, def Mention) {

   // on doit regarder ce qui apparaît en premier:

   // - ce peut être un nom, comme dans `le petit chat que j'ai adopté'

   // - ce peut être un pronom relatif, comme dans `(le livre) dans lequel

   // j'ai lu cette histoire...'

   // NOTE: dans Democrat, on n'annote pas, bizarrement, la relative dans le

   // maillon, donc, dans un GN on n'a jamais de relatif inclus.  On aura donc

   // toujours `[le petit chat] [que] [j']ai adopté'.  Mais tout le monde

   // n'annote pas de la sorte...

   for (def i=0; i<Mention.length; i++) {

         def mention = Mention[i]

         //def form = CQI.cpos2Str(word.getQualifiedName(), positions[i])[0]

         if (mention == "NOM" || mention == "NAM") {

            return "GN"

         } else if (mention == "PRO:REL") {

            return "PR_REL"

         }

    }

    return null

}

def testWhPronoun(position, mention) {

   def form = CQI.cpos2Str(word.getQualifiedName(), position)[0]

   if (mention == "PRO" && (form == "qui" || form == "que" || form == "lequel")) {

      return "PR_WH"

   }

   return null

}

def testRules(def positions, def Mention) {

	def catégorie = null

   // a possessive (mon, ma...)

   if (Mention.length == 1 && Mention.contains("DET:POS"))

      catégorie = "POSS"

   // a clitic (subject: je, tu...; object: me, te; reflexive: se)

   if (!catégorie && Mention.length == 1 && Mention.contains("PRO:PER"))

      catégorie = testClitic(positions[0], Mention[0])

   // an interrogative pronoun

   if (!catégorie && Mention.length == 1)

      catégorie = testWhPronoun(positions[0], Mention[0])

   // a noun phrase or a relative pronoun

   if (!catégorie)

      catégorie = testPhrase(positions, Mention)

   // some other kind of pronouns

   if (!catégorie

         && (   Mention.contains("PRO")

             || Mention.contains("PRO:POSS")

             || Mention.contains("PRO:IND")

             || Mention.contains("PRO:DEM")

             || Mention.contains("PRO:PER") )

         && !Mention.contains("NOM")

         && !Mention.contains("NAM") )

      catégorie = "PRO"

// Fin des règles, aucune n'a matchée. On stocke le pattern  qu'on affichera à la fin.

   if (!catégorie) {

      catégorie = "UNDEFINED" // clear the field

		def forms = CQI.cpos2Str(word.getQualifiedName(), positions)

		if (!errors.containsKey(Mention)) errors[Mention] = new HashSet()

		errors[Mention] << forms

	}

	return catégorie

}

//

// FIN DE LA DÉFINITION DES RÈGLES

//

// CORPS DU SCRIPT

if (!(corpusViewSelection instanceof MainCorpus)) {

	println "Corpora selection is not a Corpus"

	return

}

// BEGINNING OF PARAMETERS

@Field @Option(name="unit_type", usage="", widget="String", required=true, def="MENTION")

def unit_type

@Field @Option(name="pos_property_name", usage="", widget="String", required=true, def="pos")

def pos_property_name

@Field @Option(name="reset", usage="", widget="Boolean", required=true, def="true")

def reset

if (!ParametersDialog.open(this)) return

corpus = corpusViewSelection

CQI = CQPSearchEngine.getCqiClient()

word = corpus.getWordProperty()

posProperty = corpus.getProperty(pos_property_name)

if (posProperty == null) {

	println "Error: CQP corpus does not contains the word property with name=$pos_property_name"

	return

}

analecCorpus = URSCorpora.getCorpus(corpus)

vue = URSCorpora.getVue(corpus.getName())

structure = analecCorpus.getStructure()

if (!structure.getUnites().contains(unit_type)) { // check if the structure contains the unit_type units

	println "Error: corpus structure does not contains unit with name=$unit_type"

	return

}

CATEGORIE = "CATEGORIE"

// Si la structure d'annotation ne contient pas CATEGORIE, on la crée avec ses valeurs

if (!structure.getUniteProperties(unit_type).contains(CATEGORIE)) { 

// FIXME: dans le script original (see also

// http://forge.cbp.ens-lyon.fr/redmine/issues/2065), on utilise

// analecCorpus.ajouterProp/Val, mais cela ne marche pas dans ma version de

// TXM-Analec --> je retourne donc à structure.ajouterProp/Val

// la propriété

	structure.ajouterProp(Unite.class, unit_type, CATEGORIE)

// les valeurs

	structure.ajouterVal(Unite.class, unit_type, CATEGORIE, "GN")

	structure.ajouterVal(Unite.class, unit_type, CATEGORIE, "POSS")

	structure.ajouterVal(Unite.class, unit_type, CATEGORIE, "PRO")

	structure.ajouterVal(Unite.class, unit_type, CATEGORIE, "PR_CL_O")

	structure.ajouterVal(Unite.class, unit_type, CATEGORIE, "PR_CL_S")

	structure.ajouterVal(Unite.class, unit_type, CATEGORIE, "PR_CL_R")

	structure.ajouterVal(Unite.class, unit_type, CATEGORIE, "PR_REL")

	structure.ajouterVal(Unite.class, unit_type, CATEGORIE, "PR_WH")

//...

}

def nModified = 0

def nIgnored = 0

errors = new HashMap()

def units = analecCorpus.getUnites(unit_type)

units.sort() { a, b -> a.getDeb() <=> b.getDeb() ?: a.getFin() <=> b.getFin() }

for (Unite unit : units) { // process all units

	def prop = unit.getProp(CATEGORIE)

	if (!reset && prop != null && prop.length() > 0) continue // l'unité a déjà une CATEGORIE

	int[] positions = null

	if (unit.getDeb() == unit.getFin()) positions = [unit.getDeb()]

	else positions = (unit.getDeb()..unit.getFin())

	def Mention = CQI.cpos2Str(posProperty.getQualifiedName(), positions)

	def cat = testRules(positions, Mention)

	if (cat != null) {

		// following line in the original script but doesn't work for me:

      // vue.setValeurChamp(unit, CATEGORIE, cat)

      unit.getProps().put(CATEGORIE, cat)

		nModified++

	} else {

		nIgnored++

	}

}

println "Result:"

println "- $nModified units of type $unit_type have been modified."

println "- $nIgnored units of type $unit_type have not been modified.\n"

if (errors.size() > 0) {

	println "Some rules should be added to this macro to process the following remaining 'FROPOS / words' values:"

	errors.keySet().each { println "fropos="+it+"\twords="+errors[it].join(" | ") }

}

// udpate the view (also see also

// http://forge.cbp.ens-lyon.fr/redmine/issues/2065)

URSCorpora.getVue(analecCorpus).retablirVueParDefaut()

// Copyright © 2016 ENS de Lyon, CNRS, University of Franche-Comté

// Licensed under the terms of the GNU General Public License (http://www.gnu.org/licenses)

// @author mdecorde

// STANDARD DECLARATIONS

package org.txm.macro.urs

import org.kohsuke.args4j.*

import groovy.transform.Field

import org.txm.rcp.swt.widget.parameters.*

import org.txm.annotation.urs.*

import org.txm.searchengine.cqp.corpus.*

import visuAnalec.donnees.Structure;

import visuAnalec.elements.Schema

import visuAnalec.elements.Unite;

import visuAnalec.vue.Vue

if (!(corpusViewSelection instanceof MainCorpus)) {

	println "Corpora selection is not a Corpus"

	return;

}

// BEGINNING OF PARAMETERS

@Field @Option(name="unit_type",usage="", widget="String", required=true, def="MENTION")

String unit_type

if (!ParametersDialog.open(this)) return;

int nCreated = 0 // count the number of created CHAINE

int nUpdated = 0 // count the number of updated CHAINE

MainCorpus corpus = corpusViewSelection

def analecCorpus = URSCorpora.getCorpus(corpus); // analec corpus has the same name has the TXM corpus

Structure structure = analecCorpus.getStructure()

if (!structure.getUnites().contains(unit_type)) { // check if the structure contains the unit_type units

	println "Error: corpus structure does not contains unit with name=$unit_type"

	return

}

if (!structure.getSchemas().contains("CHAINE")) { // update the structure if needed

	println "Creating the 'CHAINE' schema in the structure"

	analecCorpus.ajouterType(Schema.class, "CHAINE")

	analecCorpus.ajouterProp(Schema.class, "CHAINE", "REF")

	analecCorpus.ajouterProp(Schema.class, "CHAINE", "GENRE")

	analecCorpus.ajouterVal(Schema.class, "CHAINE", "GENRE", "INDETERMINABLE")

	analecCorpus.ajouterVal(Schema.class, "CHAINE", "GENRE", "FEMININ")

	analecCorpus.ajouterVal(Schema.class, "CHAINE", "GENRE", "MASCULIN")

	analecCorpus.ajouterProp(Schema.class, "CHAINE", "NOMBRE")

	analecCorpus.ajouterVal(Schema.class, "CHAINE", "NOMBRE", "GROUPE_FLOU")

	analecCorpus.ajouterVal(Schema.class, "CHAINE", "NOMBRE", "GROUPE_STRICT")

	analecCorpus.ajouterVal(Schema.class, "CHAINE", "NOMBRE", "SINGULIER")

	analecCorpus.ajouterProp(Schema.class, "CHAINE", "NB MAILLONS")

	analecCorpus.ajouterProp(Schema.class, "CHAINE", "TYPE REFERENT")

	analecCorpus.ajouterVal(Schema.class, "CHAINE", "TYPE REFERENT", "UNKNOWN")

	analecCorpus.ajouterVal(Schema.class, "CHAINE", "TYPE REFERENT", "CONCRET_OBJECT")

	analecCorpus.ajouterVal(Schema.class, "CHAINE", "TYPE REFERENT", "ABSTRACT_OBJECT")

	analecCorpus.ajouterVal(Schema.class, "CHAINE", "TYPE REFERENT", "TIME")

	analecCorpus.ajouterVal(Schema.class, "CHAINE", "TYPE REFERENT", "PRODUCT")

	analecCorpus.ajouterVal(Schema.class, "CHAINE", "TYPE REFERENT", "AMOUNT")

	analecCorpus.ajouterVal(Schema.class, "CHAINE", "TYPE REFERENT", "EVENT")

	analecCorpus.ajouterVal(Schema.class, "CHAINE", "TYPE REFERENT", "GPE")

	analecCorpus.ajouterVal(Schema.class, "CHAINE", "TYPE REFERENT", "ORG")

	analecCorpus.ajouterVal(Schema.class, "CHAINE", "TYPE REFERENT", "PERSON")

	analecCorpus.ajouterVal(Schema.class, "CHAINE", "TYPE REFERENT", "LIEU")

}

def props = structure.getUniteProperties(unit_type)

String REF = "REF"

if (!props.contains(REF)) { // check the unit_type units have the REF property

	println "Error: $unit_type units have no proprerty named 'REF'"

	return

}

// parse the units to build CHAINES

def chaines = [:]

def units = analecCorpus.getUnites(unit_type)

units.sort() { a, b -> a.getDeb() <=> b.getDeb() ?: a.getFin() <=> b.getFin() }

for (Unite unit : units) {

	def ref = unit.getProp(REF)

	if (!chaines.containsKey(ref)) {

		chaines[ref] = []

	}

	chaines[ref] << unit

}

// update the already existing CHAINES schemas

for (Schema schema : analecCorpus.getSchemas("CHAINE")) {

	String ref = schema.getProp(REF)

	if (chaines.containsKey(ref)) { // the CHAINE exists 

		// maj des unités de la chaine existante

		int size_before = schema.getContenu().size()

		for (def unit : chaines[ref]) schema.ajouter(unit) // insert the new units in the hashset

		// Update the CHAINE size

		schema.props.put("NB MAILLONS", Integer.toString(schema.contenu.size())) 

		// remove the inserted CHAINE from 'chaines'

		chaines.remove(ref)

		if (size_before < schema.getContenu().size()) // if the size changed, then the CHAIEN have been updated

			nUpdated++

	}

}

// create the remaining CHAINES schemas

for (def ref : chaines.keySet()) { // process the remaining CHAINE of 'chaines'

	nCreated++;

	Schema schema = new Schema()

	schema.type = "CHAINE"

	schema.props.put("REF", ref) 

	schema.props.put("GENRE", "") // set default values

	schema.props.put("NOMBRE", "") // set default values

	schema.props.put("NB MAILLONS", Integer.toString(chaines[ref].size())) 

	schema.props.put("TYPE REFERENT", "") // set default values

	for (def unit : chaines[ref]) schema.ajouter(unit) // insert the new units in the hashset

	analecCorpus.addSchemaLu(schema)  // add the new schema

}

println "nUpdated=$nUpdated"

println "nCreated=$nCreated"

// STANDARD DECLARATIONS

package org.txm.macro.urs

import org.kohsuke.args4j.*

import groovy.transform.Field

import org.txm.rcp.swt.widget.parameters.*

import org.txm.annotation.urs.*

import org.txm.searchengine.cqp.corpus.*

import visuAnalec.elements.*

if (!(corpusViewSelection instanceof MainCorpus)) {

	println "Corpora selection is not a Corpus"

	return;

}

@Field @Option(name="I_AM_SURE_IWANT_TO_RESET_THE_ANNOTATIONS", usage="an example boolean", widget="Boolean", required=false, def="false")

def I_AM_SURE_IWANT_TO_RESET_THE_ANNOTATIONS

// Open the parameters input dialog box

if (!ParametersDialog.open(this)) return;

MainCorpus corpus = corpusViewSelection

def analecCorpus = URSCorpora.getCorpus(corpus);

def structure = analecCorpus.getStructure()

Class[] classes = [Unite.class, Relation.class, Schema.class]

println "Removing unites..."

for (String type : structure.getTypes(Unite.class)) {

	for (Unite unite : analecCorpus.getUnites(type).toArray(new Unite[0])) {

		analecCorpus.supUnite(unite)

	}

//	fireMessage(new StructureEvent(analecCorpus, TypeModifStructure.SUPPR_TYPE, Unite.class, type));

}

println "Removing relations..."

for (String type : structure.getTypes(Relation.class)) {

	for (Relation relation : analecCorpus.getRelations(type).toArray(new Relation[0])) {

		analecCorpus.supRelation(relation)

	}

//	fireMessage(new StructureEvent(analecCorpus, TypeModifStructure.SUPPR_TYPE, Relation.class, type));

}

println "Removing schemas..."

for (String type : structure.getTypes(Schema.class)) {

	for (Schema schema : analecCorpus.getSchemas(type).toArray(new Schema[0])) {

		analecCorpus.supSchema(schema)

	}

//	fireMessage(new StructureEvent(analecCorpus, TypeModifStructure.SUPPR_TYPE, Schema.class, type));

}

println "Done. Save the corpus to finish the reset."

// Copyright © 2016 ENS de Lyon, CNRS, University of Franche-Comté

// Licensed under the terms of the GNU General Public License (http://www.gnu.org/licenses)

// @author mdecorde

// @author sheiden

// STANDARD DECLARATIONS

package org.txm.macro.urs

import org.apache.commons.lang.StringUtils;

import org.apache.tools.ant.types.resources.selectors.InstanceOf;

import org.kohsuke.args4j.*

import groovy.transform.Field

import org.txm.Toolbox;

import org.txm.rcp.swt.widget.parameters.*

import org.txm.annotation.urs.*

import org.txm.searchengine.cqp.AbstractCqiClient;

import org.txm.searchengine.cqp.corpus.*

import visuAnalec.donnees.Structure;

import visuAnalec.elements.Relation

import visuAnalec.elements.Unite;

if (!(corpusViewSelection instanceof MainCorpus)) {

	println "Corpora selection is not a Corpus"

	return;

}

// BEGINNING OF PARAMETERS

@Field @Option(name="relation_type",usage="", widget="String", required=true, def="ANAPHORE")

String relation_type

if (!ParametersDialog.open(this)) return;

MainCorpus corpus = corpusViewSelection

AbstractCqiClient CQI = CQPSearchEngine.getCqiClient();

def word = corpus.getWordProperty()

def analecCorpus = URSCorpora.getCorpus(corpus);

int n = 1;

def relations = analecCorpus.getRelations(relation_type)

for (Relation relation : relations) {

	def unit1 = relation.getElt1();

	def unit2 = relation.getElt2();

	def props = relation.getProps()

	if (unit1 instanceof Unite && unit2 instanceof Unite) {

		int[] pos1 = null

		if (unit1.getDeb() == unit1.getFin()) pos1 = [unit1.getDeb()]

		else pos1 = (unit1.getDeb()..unit1.getFin())

		def form1 = StringUtils.join(CQI.cpos2Str(word.getQualifiedName(), pos1), " ")

		int[] pos2 = null

		if (unit2.getDeb() == unit2.getFin()) pos2 = [unit2.getDeb()]

		else pos2 = (unit2.getDeb()..unit2.getFin())

		def form2 = StringUtils.join(CQI.cpos2Str(word.getQualifiedName(), pos2), " ")

		println "$n - $props : $form1 -> $form2"

	} else {

		println "$n - $props"

	}

	n++

}

// Copyright © 2016 ENS de Lyon, CNRS, University of Franche-Comté

// Licensed under the terms of the GNU General Public License (http://www.gnu.org/licenses)

// @author mdecorde

// @author sheiden

// STANDARD DECLARATIONS

package org.txm.macro.urs

import org.kohsuke.args4j.*

import groovy.transform.Field

import org.txm.rcp.swt.widget.parameters.*

import org.txm.annotation.urs.*

import org.txm.searchengine.cqp.corpus.*

if (!(corpusViewSelection instanceof MainCorpus)) {

	println "Corpora selection is not a Corpus"

	return;

}

@Field @Option(name="unit_type",usage="", widget="String", required=false, def="Maillon")

String unit_type

@Field @Option(name="unit_property_name", usage="", widget="String", required=false, def="")

String unit_property_name

@Field @Option(name="unit_property_value", usage="", widget="String", required=false, def=".*")

String unit_property_value

if (!ParametersDialog.open(this)) return;

// END OF PARAMETERS

MainCorpus corpus = corpusViewSelection

def analecCorpus = URSCorpora.getCorpus(corpus);

// check unit parameters

if (!analecCorpus.getStructure().getUnites().contains(unit_type)) {

	println "No unit with name=$unit_type"

	return;

} else {

	if (unit_property_name.length() > 0 && unit_property_value.length() > 0) {

		// test property existance

		def props = analecCorpus.getStructure().getUniteProperties(unit_type);

		if (!props.contains(unit_property_name)) {

			println "Unit $unit_type has no property named $unit_property_name"

			return;

		}

	}

}

int nMots = corpus.getSize();

int nUnites = 0;

	for (def unit : analecCorpus.getToutesUnites()) {

		if (unit_type.length() > 0) {

			if (!unit.getType().equals(unit_type)) {

				continue

			}

		}

		if (unit_property_name.length() > 0 && unit_property_value.length() > 0) {

			if (!unit.getProp(unit_property_name).matches(unit_property_value)) {

				// ignoring this schema

				continue

			}

		}

		nUnites++

	}

coef = (nUnites /nMots)

println "densité référentielle : nUnites/nMots = $nUnites/$nMots = $coef = ${coef*100}%"

if (nUnites >= nMots) {

	println "WARNING: possible encoding error. Number of units ($nUnites) is greater than number of words ($nMots)"

}

return ["result":coef, "data":["nUnites":nUnites, "nMots":nMots]]

// Copyright © 2016 ENS de Lyon, CNRS, University of Franche-Comté

// Licensed under the terms of the GNU General Public License (http://www.gnu.org/licenses)

// @author mdecorde

// @author sheiden

// STANDARD DECLARATIONS

package org.txm.macro.urs

import org.apache.commons.lang.StringUtils;

import org.kohsuke.args4j.*

import groovy.transform.Field

import org.txm.Toolbox;

import org.txm.rcp.swt.widget.parameters.*

import org.txm.annotation.urs.*

import org.txm.searchengine.cqp.AbstractCqiClient;

import org.txm.searchengine.cqp.CQPSearchEngine

import org.txm.searchengine.cqp.corpus.*

import visuAnalec.donnees.Structure;

import visuAnalec.elements.Unite;

if (!(corpusViewSelection instanceof MainCorpus)) {

	println "Corpora selection is not a Corpus"

	return;

}

// BEGINNING OF PARAMETERS

@Field @Option(name="unit_type",usage="", widget="String", required=true, def="MENTION")

String unit_type

if (!ParametersDialog.open(this)) return;

MainCorpus corpus = corpusViewSelection

AbstractCqiClient CQI = CQPSearchEngine.getCqiClient();

def word = corpus.getWordProperty()

def analecCorpus = URSCorpora.getCorpus(corpus);

int n = 1;

def units = analecCorpus.getUnites(unit_type)

units.sort() { a, b -> a.getDeb() <=> b.getDeb() ?: a.getFin() <=> b.getFin() }