Laboratoire ICAR » Plateforme TXM

			boolean b = concordance.getQueryResultParameter() == null;

			this.queryWidget.setEnabled(b); // disable the widget if a QueryResult was provided

	public void setEnabled(boolean b) {

		super.setEnabled(b);

		querywidget.setEnabled(b);

	}

	public QueryResult getQueryResultParameter() {

		return pQueryResult;

	}

import org.txm.chartsengine.core.preferences.ChartsEnginePreferences

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="sep", usage="Schemas and units selection part", widget="Separator", required=false, def="Selection")

@Field @Option(name="sep2", usage="Progression command parameters", widget="Separator", required=false, def="Progression")

	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()

	}

			if (debug) println "corpus matches: "+corpus.getMatches()

	try {

		def struct = corpus.getStructuralUnit(struct_name);

		def struct_p = null;

		if (struct != null) {

			struct_p = struct.getProperty(struct_prop)

		}

		Progression progression = new Progression(corpus);

		progression.setParameters(queries,

				struct, struct_p,	".*",

				cummulative, line_width, false, bande_width)

		progression.setQueryResults(queryResults); // new

		progression.setParameter(ChartsEnginePreferences.SHOW_LEGEND, show_legend);

		progression.setParameter(ChartsEnginePreferences.SHOW_TITLE, show_title);

		progression.compute()

		if (!progression.stepStructuralUnits() || monitor.isCanceled())	return

			monitor.worked(20)

		if (!progression.stepFinalize() || monitor.isCanceled()) return

			monitor.worked(20)

		monitor.syncExec(new Runnable() {

					@Override

					public void run() {

						try {

							//def charteditorpart = org.txm.chartsengine.rcp.SWTChartsComponentsProvider.openEditor(Application.swtComponentProvider.createProgressionChartEditorPart(IImageKeys.getImage(IImageKeys.ACTION_PROGRESSION), progression, progression.isMonochrome(), progression.isMonostyle(), progression.isDoCumulative()))

							def charteditorpart = org.txm.chartsengine.rcp.editors.ChartEditor.openEditor(progression);

//							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)

						} catch(Exception e) {e.printStackTrace()}

					}

				})

	} catch(Exception e) {

		e.printStackTrace()

		return false

	}

} else {

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

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)

}

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 CQI = CQPSearchEngine.getCqiClient()

	if (buildCQL) {

		word_prop = corpus.getProperty("id")

	} else {

		word_prop = corpus.getProperty(word_property)

	}

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

	schemas.sort() {it.getProps()}

	def nSchemas = 0

	def lens = [:]

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

	for (def schema : schemas) {

		def allUnites = schema.getUnitesSousjacentesNonTriees()

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

		print schema.getProps().toString()+ ": "

		def first = true

		for (def unit : units) {

			String forme =  null;

			if (buildCQL) {

				def first2= true

				q = ""

				pos.each {

					if (first2) { first2 = false } else { q = q+" " }

					int[] pos2 = [it]

					q = q+"["+word_prop+"=\""+CQI.cpos2Str(word_prop.getQualifiedName(), pos2)[0]+"\"]"

				}

				if (first) { first = false } else { print "|" }

				print "("+q+")"

			} else {

				if (word_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(word_prop.getQualifiedName(), pos), " ") // ids is enough

				}

				if (first) { first = false } else { print separator }

				print forme

		println ""

		nSchemas++

}

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)

}

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);

	def distances = [];

	def nDistances = 0

	def cadences = [];

	for (def schema : schemas) {

		def allUnites = schema.getUnitesSousjacentesNonTriees()

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

		Collections.sort(units)

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

			int d1 = 0;

			int d2 = 0;

			if (i < units.size()-1) d1 = units[i+1].getDeb() - units[i].getFin();

			if (d1 < 0) {

				//println "D1 "+units[i+1].getDeb()+" - "+units[i].getFin()+" = "+d1

				d1 = 0; // the first unit pass the next one ?

			}

			if (i > 0) d2 = units[i].getDeb() - units[i-1].getFin();

			if (d2 < 0) {

				//println "D2 "+units[i].getDeb()+" - "+units[i-1].getFin()+" = "+d2

				d2 = 0; // the first unit pass the next one ?

			}

			distances << d1

			if (d1 < d2) cadences << d1 else cadences << d2

			nDistances++

	distances = distances.sort()

	cadences = cadences.sort()

	int distances_total = distances.sum()

	int cadences_total = cadences.sum()

	coef = (distances_total / nDistances)

	cadence = (cadences_total / nDistances)

	println "$corpus distances:"

	//println "distances $distances"

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

	println "distance medianne inter-mayonnaise : "+distances[(int)(distances.size() / 2)]

	println "distance quartils : "+distances[0]+" "+distances[(int)(distances.size() / 4)] + " "+distances[(int)(distances.size() / 2)]+" "+distances[(int)(3*distances.size() / 4)]+" "+distances[(int)(distances.size() -1)]

	//println "cadences $cadences"

	println "cadence moyenne : $cadences_total / $nDistances = $cadence"

	println "cadence medianne : "+cadences[(int)(cadences.size() / 2)]

	println "cadence quartils : "+cadences[0]+" "+cadences[(int)(cadences.size() / 4)] + " "+cadences[(int)(cadences.size() / 2)]+" "+cadences[(int)(3*cadences.size() / 4)]+" "+cadences[(int)(cadences.size() -1)]

	//return ["result":coef, "result2":cadence, "data":["distances":distances, "nDistances":nDistances, "cadences":cadences]]

} else {

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

} else {

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

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=VALUE", widget="String", required=false, def="CHAINE")

@Field @Option(name="minimum_schema_size", usage="Minimum size needed to consider a schema", widget="Integer", required=false, def="3")

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

@Field @Option(name="position_in_schema", usage="Unit distance in schema (0 = no selection, 1 = first after limit, -1 = last before limit, etc.)", widget="Integer", required=false, def="0")

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

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

@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=false, def="0")

for (def corpus : selection) {

println "$corpus referential density: nUnites/nMots = $nUnites/$nMots = $coef = ${coef*100}%"

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

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

}

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)

}

		String schema_ursql

		int minimum_schema_size

		int maximum_schema_size

		String schema_property_display

		String unit_ursql

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

		output_graph = false

		debug

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);

	int nSchemas = 0;

	def lens = [:]

	def lensnames = [:]

	for (def schema : schemas) {

		def allUnites = schema.getUnitesSousjacentesNonTriees()

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

		int nUnites = units.size();

		if (!lens.containsKey(nUnites)) {

			lens[nUnites] = 0;

			lensnames[nUnites] = [];

		}

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

		lensnames[nUnites] << 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]

	}

	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)+"	"+lensnames[it.key] }

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

	if (output_graph) {

		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()

		println "corpusName=$corpusName"

		def PNGFile = File.createTempFile("txm_"+corpus.getID()+"_", ".png", new File(Toolbox.getTxmHomePath(), "results"))

		def PNGFilePath = PNGFile.getAbsolutePath()

		println "PNG file: "+PNGFilePath

		def SVGFile = File.createTempFile("txm_"+corpus.getID()+"_", ".svg", new File(Toolbox.getTxmHomePath(), "results"))

		def SVGFilePath = SVGFile.getAbsolutePath()

		println "SVG file: "+SVGFilePath

		/// BEGINNING OF R SCRIPT

		def script ="""

		/// END OF R SCRIPT

		// execute R script

		r.plot(PNGFile, "png(file = \"${PNGFilePath}\"); "+script)

		r.plot(SVGFile, "svg(file = \"${SVGFilePath}\"); "+script)

		//display the SVG results graphic

		monitor.syncExec(new Runnable() {

					@Override

					public void run() { OpenBrowser.openfile(SVGFile.getAbsolutePath(), corpusName+" Longueur des chaînes") }

				})

	}

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

}

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)

}

for (def corpus : selection) {

	def analecCorpus = URSCorpora.getCorpus(corpus)

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

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

	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 CQI = CQPSearchEngine.getCqiClient()

	def prop = corpus.getProperty(word_property)

	if (prop == null) { // no CQP property called $word_property

		errors=AnalecUtils.isPropertyDefined(Unite.class, analecCorpus, AnalecUtils.getFilterParameters(unit_ursql)[0], word_property)

		if (errors.size() > 0) {

			println "** $word_property unit property 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);

	allFormesSet = new HashSet();

	def coefs = []

	int n = 1

	int nUnitesAllSchemas = 0

	int nUnitesTotalSchemas = 0

	println "** $corpus schemas: "

	for (def schema : schemas) {

		def formesSet = new HashSet(); // contient toutes les formes du CR courant

		nUnitesTotal = 0;

		def allUnites = schema.getUnitesSousjacentesNonTriees()

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

		def nUnites = schema.getUnitesSousjacentes().size()

		def nUnitesTotal = units.size()

		for (def unit : units) {

			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

			}

			formesSet.add(forme)

		}

		if (formesSet.size() == 0 || nUnitesTotal == 0) {

			coef = "NA"

		} else {

			coef = (nUnitesTotal/formesSet.size())

		}

		coefs << coef

		allFormesSet.addAll(formesSet)

		if (schema_display_property_name != null && schema_display_property_name.length() > 0) {

			print schema.getProp(schema_display_property_name)

		} else {

			print schema_ursql+"-"+n+" : "

		}

		println " ($nUnites units) : $nUnitesTotal selected units / ${formesSet.size()} ${word_property}s = $coef"

		if (show_values) {

			println "\t${word_property}s="+formesSet

		}

		n++

		nUnitesAllSchemas += nUnites

		nUnitesTotalSchemas += nUnitesTotal

	coef = nUnitesTotalSchemas/allFormesSet.size()

	//println "ALL : ($nUnitesAllSchemas units) : $nUnitesTotalSchemas selected units / ${allFormesSet.size()} ${word_property}s = $coef"

//	return ["result":coefs, "data":["nUnitesTotal":nUnitesTotalSchemas, "allFormesSet":allFormesSet], "coef":(coef)]

import org.txm.lexicaltable.core.functions.LexicalTable

} else {

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

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

@Field @Option(name="minimum_schema_size", usage="Minimum size needed to consider a schema", widget="Integer", required=false, def="3")

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

@Field @Option(name="unit_property_display", usage="Unit property to count", widget="String", required=false, def="CATEGORIE")

@Field @Option(name="position_in_schema", usage="Unit distance in schema (0 = no selection, 1 = first after limit, -1 = last before limit, etc.)", widget="Integer", required=false, def="0")

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

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

@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=false, def="0")

@Field @Option(name="output_showlegend", usage="output barplot or 3D plot", widget="Boolean", required=false, def="true")

@Field @Option(name="output_fmin", usage="minimal frequency displayed", widget="Integer", required=false, def="0")

@Field @Option(name="output_histogram", usage="show or not a histogram of the result", widget="Boolean", required=false, def="true")

@Field @Option(name="output_lexicaltable", usage="create or not a lexical table with the result", widget="Boolean", required=false, def="false")

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

	def parent = selection[0]

	println "parent="+parent.getClass()

	if (parent instanceof Part) {

		println "part="+parent

		parent = parent.getParent()

		println "partition="+parent

		lt = new LexicalTable(parent);

		lt.setData(new LexicalTableImpl(matrix as DoubleMatrix2D, rownames, colnames))

		lt = new LexicalTable(parent);

		lt.setData(new LexicalTableImpl(matrix as DoubleMatrix2D, rownames, colnames))

	lt.setUserName(schema_ursql+">"+unit_ursql)

} else {

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

} else {

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

	println "Annotating $corpus..."

   <feature url="features/org.txm.backtomedia.feature_1.0.0.201905221522.jar" id="org.txm.backtomedia.feature" version="1.0.0.201905221522">

   <feature url="features/org.txm.wordcloud.feature_1.0.0.201905221522.jar" id="org.txm.wordcloud.feature" version="1.0.0.201905221522">

   <feature url="features/org.txm.treetagger.binaries.feature_1.0.0.201905221522.jar" id="org.txm.treetagger.binaries.feature" version="1.0.0.201905221522" os="" ws="">

   <feature url="features/org.txm.treetagger.models.feature_1.0.0.201905221522.jar" id="org.txm.treetagger.models.feature" version="1.0.0.201905221522">

   <feature url="features/org.txm.annotation.urs.feature_1.0.0.201905221522.jar" id="org.txm.annotation.urs.feature" version="1.0.0.201905221522">

   <feature url="features/org.txm.tigersearch.feature_1.0.0.201905221522.jar" id="org.txm.tigersearch.feature" version="1.0.0.201905221522">

	/** stores the data computed */

	 * true if the data has been set with lt.setData(...)

	 */

	@Parameter(key=LexicalTablePreferences.EXTERN_DATA)

	protected boolean pExternData;

	/**

	protected LexicalTableImpl _computeFromPartition(Partition partition) throws Exception {

			return null;

		return new LexicalTableImpl(mat, filteredForms.toArray(new String[]{}), partition.getPartNames().toArray(new String[] {}));

	protected LexicalTableImpl _computeFromIndexes(List<PartitionIndex> indexes) throws RWorkspaceException {

			throw new IllegalArgumentException("Index is not computed with a partition. Aborting.");

				return null;

		return new LexicalTableImpl(mat, rownames.toArray(new String[] {}), colnames.toArray(new String[] {}));

		if (pExternData) {

			return statsData != null;

		}

			this.statsData = this._computeFromPartition((Partition)this.parent);

			this.statsData = this._computeFromIndexes(Arrays.asList((PartitionIndex)this.parent));

	/**

	 * Use this method to set manually data to the lexical table

	 * @param lexicalTableImpl external data to use. If null the table will be computed using its parent

	 */

		this.pExternData = statsData != null;

		setAltered();

	/**

	 * If true, the table data has been manually set with lt.setData(lexicalTableImpl)

	 */

	public static final String EXTERN_DATA = "extern_data"; //$NON-NLS-1$

		preferences.putBoolean(EXTERN_DATA, false);

			path = path.substring(5);