Laboratoire ICAR » Plateforme TXM

							JFreeChart chart = charteditorpart.getChart()

							def plot = chart.getXYPlot()

							ProgressionItemSelectionRenderer renderer = plot.getRenderer();

							//renderer.setBaseItemLabelsVisible(true)

							//renderer.setBaseLinesVisible(false)

							//renderer.setBaseSeriesVisible(SchemasProgressionMacro.this.show_lines, true);

							//renderer.setItemLabelsVisible(true)

							//renderer.setLinesVisible(false)

							renderer.setAdditionalLabelInformation(informations)

							renderer.setAdditionalShapeScales(styles)

							chart.getLegend().setVisible(SchemasProgressionMacro.this.show_legend)

							chart.getTitle().setVisible(SchemasProgressionMacro.this.show_title)

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

@Field @Option(name="cql_limit", usage="CQL to build structure limits", widget="Query", required=false, def="")

cql_limit

@Field @Option(name="position_in_matches", usage="Unit distance to structure limit (0 = no selection, 1 = first after limit, -1 = last before limit, etc.)", widget="Integer", required=true, def="0")

int position_in_matches

	errors = AnalecUtils.isPropertyDefined(Unite.class, analecCorpus, unit_ursql)

	def word_prop = null

	println "$corpus schemas (${schemas.size()}): "

		units = AnalecUtils.filterUniteByInclusion(debug, allUnites, corpus.getMatches(), false, 0)

		if (cql_limit != null) {

			def cql_limit_matches = null;

			if (cql_limit != null && !cql_limit.getQueryString().equals("\"\"")) {

				def limitssubcorpus = corpus.createSubcorpus(cql_limit, corpus.getName().toUpperCase())

				cql_limit_matches = limitssubcorpus.getMatches();

				limitssubcorpus.delete();

			} else {

				cql_limit_matches = corpus.getMatches()

			}

			units = AnalecUtils.filterUniteByInclusion(debug, units, cql_limit_matches, strict_inclusion, position_in_matches)

		}

		print schema.getProps().toString()+ " ("+units.size()+"/"+allUnites.size()+"): "

		def values = new HashSet()

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

				values << forme

		println values.join(separator)

	def word = corpus.getWordProperty()

	def analecCorpus = URSCorpora.getCorpus(corpus)

	def errors = AnalecUtils.isPropertyDefined(Schema.class, analecCorpus, schema_ursql)

	if (errors.size() > 0) {

		println "** The $schema_ursql schema URSQL cannot be computed in the corpus with types: $errors."

		return;

	}

	errors = AnalecUtils.isPropertyDefined(Unite.class, analecCorpus, unit_ursql)

	if (errors.size() > 0) {

		println "** $unit_ursql unit URSQL cannot be computed in the corpus with types: $errors."

		return;

	}

		String unit_ursql, Integer position_in_schema, CQLQuery cql_limit, Boolean strict_inclusion, int position_in_matches) {

		def selectedUnits = AnalecUtils.filterUniteByInclusion(debug, groupedUnits[k], matches, strict_inclusion, position_in_matches)

import visuAnalec.elements.*

// get the Analec corpus : stores the annotations and annotation structure

// get the annotations structure : stores the available annotation types, properties and values

// get the annotations view : stores annotations and annotation structure display rules

// display annotations per Element type (Unite, Relation, Schema) and per type

	// Create annotation type

	structure.ajouterType(Unite.class, "EXEMPLE");

	//structure.ajouterType(Relation.class, "EXEMPLE");

	//structure.ajouterType(Schema.class, "EXEMPLE");

	println structure.getTypes(Unite.class)

	// Create annotation property

	structure.ajouterProp(Unite.class, "EXEMPLE", "PEXEMPLE")

	println structure.getNomsProps(Unite.class, "EXEMPLE")

	// Create annotation value

	structure.ajouterVal(Unite.class, "EXEMPLE", "PEXEMPLE", "oui")

	structure.ajouterVal(Unite.class, "EXEMPLE", "PEXEMPLE", "non")

	def props = [:]

	props["PEXEMPLE"] = "oui"

	def u = analecCorpus.addUniteSaisie("EXEMPLE", 0, 10, props)

	println u

	u.getProps()["EXEMPLE"] = "non"

	// Unit getters

	println u.getDeb() // start of unit

	println u.getFin() // end of unit

	println u.getProp("EXEMPLE")

	println u.getType()

	// Browse Units

		println "Units:"

		for (String type : structure.getUnites()) {

			def units = analecCorpus.getUnites(type)

			if (units.size() > 0) {

				println "	${units.size()} $type"

			}

		}

		// Browse Relations

		println "Relations:"

		for (String type : structure.getRelations()) {

			def relations = analecCorpus.getRelations(type)

			if (relations.size() > 0) {

				println "	${relations.size()} $type"

			}

		}

		// Browse Schemas

		println "Schemas:"

		for (String type : structure.getSchemas()) {

			def schemas = analecCorpus.getSchemas(type)

			if (schemas.size() > 0) {

				println "	${schemas.size()} $type"

			}

		}

	analecCorpus.supUnite(u)

	//analecCorpus.supRelation(rel)

	//analecCorpus.supSchema(sch)

	// Delete annotation value

	structure.supprimerVal(Unite.class, "EXEMPLE", "PEXEMPLE", "oui")

	structure.supprimerVal(Unite.class, "EXEMPLE", "PEXEMPLE", "non")

	// Delete annotation property

	structure.supprimerProp(Unite.class, "EXEMPLE", "PEXEMPLE")

	// Delete annotation type

	structure.supprimerType(Unite.class, "EXEMPLE");

	//structure.supprimerType(Relation.class, "EXEMPLE");

	//structure.supprimerType(Schema.class, "EXEMPLE");

	//URSCorpora.revert(corpus);

	//URSCorpora.saveCorpus(corpus)

// 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.macroprototypes.urs.exploit

import org.kohsuke.args4j.*

import groovy.transform.Field

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

import org.txm.annotation.urs.*

import org.txm.macro.urs.AnalecUtils

import visuAnalec.elements.*

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

import org.txm.Toolbox

import org.txm.rcp.commands.*

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

def selection = []

for (def s : corpusViewSelections) {

	if (s instanceof CQPCorpus) selection << s

	else if (s instanceof Partition) selection.addAll(s.getParts())

}

if (selection.size() == 0) {

	println "** $scriptName: please select a Corpus or a Partition in the Corpus view: "+corpusViewSelections

	return false

} else {

	for (def c : selection) c.compute(false)

}

@Field @Option(name="schema_ursql", usage="TYPE@PROP=REGEX", widget="String", required=true, def="CHAINE")

		String schema_ursql

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

		int minimum_schema_size

@Field @Option(name="maximum_schema_size", usage="Maximum size needed to consider a schema", widget="Integer", required=true, def="9999999")

		int maximum_schema_size

@Field @Option(name="schema_property_display", usage="schema property to show", widget="String", required=true, def="REF")

		String schema_property_display

@Field @Option(name="unit_ursql", usage="TYPE@PROP=REGEX", widget="String", required=false, def="MENTION")

		String unit_ursql

@Field @Option(name="strict_inclusion", usage="Units must be strictly included into corpus matches", widget="Boolean", required=true, def="true")

		boolean strict_inclusion

@Field @Option(name="position_in_matches", usage="Unit distance to structure limit (0 = no selection, 1 = first after limit, -1 = last before limit, etc.)", widget="Integer", required=true, def="0")

		int position_in_matches

@Field @Option(name="sep", usage="choose between the len or freq columns", widget="Separator", metaVar="freq	len", required=true, def="")

		def sep

@Field @Option(name="sort_column", usage="choose between the len or freq columns", widget="StringArray", metaVar="freq	len", required=true, def="freq")

		String sort_column

@Field @Option(name="max_lines", usage="cut the number of lines shown. '0' means no cut", widget="Integer", required=false, def="0")

		int max_lines

//@Field @Option(name="output_graph", usage="Show chart", widget="Boolean", required=true, def="false")

		output_graph = false

@Field @Option(name="debug", usage="Show internal variable content", widget="StringArray", metaVar="OFF	ON	ALL	REALLY ALL", required=true, def="OFF")

		debug

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

if (debug == "OFF") debug = 0; else if (debug == "ON") debug = 1; else if (debug == "ALL") debug = 2 else if (debug == "REALLY ALL") debug = 3

for (def corpus : selection) {

	def analecCorpus = URSCorpora.getCorpus(corpus)

	def errors = AnalecUtils.isPropertyDefined(Schema.class, analecCorpus, schema_ursql)

	if (errors.size() > 0) {

		println "** The $schema_ursql schema URSQL cannot be computed in the corpus with types: $errors."

		return;

	}

	errors=AnalecUtils.isPropertyDefined(Unite.class, analecCorpus, unit_ursql)

	if (errors.size() > 0) {

		println "** $unit_ursql unit URSQL cannot be computed in the corpus with types: $errors."

		return;

	}

	def schemas = AnalecUtils.selectSchemasInCorpus(debug, analecCorpus, corpus, schema_ursql, minimum_schema_size, maximum_schema_size, strict_inclusion);

	int nSchemas = 0;

	def scores = [:]

	def lensnames = [:]

	for (def schema : schemas) {

		def allUnites = schema.getUnitesSousjacentesNonTriees()

		def units = AnalecUtils.filterElements(debug, allUnites, unit_ursql)

		selectedUnits = AnalecUtils.filterUniteByInclusion(debug, units, corpus.getMatches(), strict_inclusion, position_in_matches)

		int nUnites = selectedUnits.size();

		if (!scores.containsKey(schema)) {

			scores[schema] = 0;

		}

		scores[schema] = units.su

		String value = schema.getProp(schema_property_display);

		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]

	}

	if (n == 0) {

		println "No units selected for schemas=$schema_ursql and units=$unit_ursql"

		return false;

	}

	coef = (t/n)

	def slens = null

	if ("freq".equals(sort_column)) {

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

	} else {

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

	}

	def flens = []

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

	def nbins = flens.size()*2

	println "Schema scores in '$corpus'. The average schema score is $t/$n = "+coef

	println "Index:\nlen\tfreq\tcfreq"

	int nShown = 0;

	for( def it : slens) {

		println it.key+"	"+it.value+"	"+(cfreq+=it.value)+"	"+lensnames[it.key].join(", ")

		nShown++

		if (max_lines > 0 && nShown >= max_lines) {

			println "... (${slens.size() - max_lines})"

			break;

		}

	}

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

}

		try {

			defaultGSE.getGroovyClassLoader().addClasspath(jardir.getAbsolutePath());

			defaultGSE.getGroovyClassLoader().addURL(jardir.toURI().toURL());

		} catch (MalformedURLException e) {

			// TODO Auto-generated catch block

			e.printStackTrace();

		}

					return name.endsWith(".jar") || name.endsWith(".so") || name.endsWith(".dylib") || name.endsWith(".dll"); //$NON-NLS-1$

	public void setAdditionalShapeScales(List<List<Double>> shapeScales) {

		this.additionalShapesScale = shapeScales;

	}

	public void setAdditionalLabelInformation(List<List<String>> informations) {

		this.additionalInformations = informations;

	}

		if (additionalInformations != null) {

			if (additionalInformations.size() > series) {

				if (additionalInformations.get(series).size() > item) {

					label += "\n "+additionalInformations.get(series).get(item);

				}

			}

		}

 		  EntityCollection entities = null;

          if(info != null) {

          	entities = info.getOwner().getEntityCollection();

          }

          drawSecondaryPass(g2, plot, dataset, pass, series, item, domainAxis, dataArea, rangeAxis, crosshairState, entities);

		if (this.parent.isDisposed()) return; // nothing to refresh

		if (!topToolBar.isDisposed()) this.topToolBar.redraw();