Laboratoire ICAR » Plateforme TXM

	public boolean process(File outfile) {

	if (!v2t.process(outFile)) {

package org.txm.macro.projects.nov13

import java.time.LocalTime

import java.time.format.DateTimeFormatter

import org.txm.utils.*

import org.txm.utils.logger.*

@Field @Option(name="trsFile", usage="A single vocapia XML file", widget="FileOpen", required=false, def="")

		File trsFile;

@Field @Option(name="trsDirectory", usage="A Vocapia XML files directory to process", widget="Folder", required=false, def="")

		File trsDirectory;

@Field @Option(name="resultDirectory", usage="The result directory", widget="Folder", required=false, def="")

		File resultDirectory;

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

if (resultDirectory.equals(trsDirectory) || (trsFile != null && trsFile.getParentFile().equals(resultDirectory))) {

	return false;

}

resultDirectory.mkdirs();

def trsFiles = []

if (trsDirectory != null && trsDirectory.exists()) {

	println "Processing TRS directory: $trsDirectory"

	for (File file : trsDirectory.listFiles()) {

		if (file.getName().toLowerCase().endsWith(".trs")) {

			trsFiles << file

		}

	}

} else if (trsFile != null && trsFile.exists()) {

	println "Processing TRS file: $trsFile"

	trsFiles << trsFile

}

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

	println "No XML file found for parameters trsFile=$trsFile and trsDirectory=$trsDirectory"

	return false

}

ConsoleProgressBar cpb = new ConsoleProgressBar(trsFiles.size())

for (File file : trsFiles) {

	cpb.tick()

	FixTranscription fixer = new FixTranscription(file)

	String name = FileUtils.stripExtension(file)

	File outFile = new File(resultDirectory, name+".trs")

	if (!fixer.process(outFile)) {

		println "WARNING: ERROR WHILE PROCESSING: "+file

		return false

	}

}

cpb.done()

println "Done: "+trsFiles.size()+" files processed. Result files in $resultDirectory"

package org.txm.macro.projects.nov13

import javax.xml.stream.*

import org.txm.importer.PersonalNamespaceContext

import org.txm.xml.IdentityHook

import org.txm.xml.*

import java.io.BufferedOutputStream

import java.io.FileOutputStream

import java.io.IOException

import java.net.URL

import java.util.*

import java.util.Map.Entry

import java.util.regex.Pattern

class FixTranscription extends XMLProcessor {

	LocalNamesHookActivator activator;

	IdentityHook hook;

	public FixTranscription(File xmlfile) {

		super(xmlfile)

		activator = new LocalNamesHookActivator<>(hook, ["w", "Turn", "Sync"]);

		hook = new IdentityHook("word_hook", activator, this) {

					boolean inTurn = false;

					boolean inW = false;

					StringBuilder wordBuffer = new StringBuilder();

					String currentTime;

					LinkedHashMap turnInfos = new LinkedHashMap()

					LinkedHashMap wInfos = new LinkedHashMap()

					boolean other

					@Override

					public boolean deactivate() {

						return true;

					}

					@Override

					public boolean _activate() {

						return true;

					}

					@Override

					protected void processStartElement() throws XMLStreamException, IOException {

						if (localname.equals("Turn")) {

							// store values

							inTurn = true;

							turnInfos.clear()

							for (int i = 0 ; i < parser.getAttributeCount() ; i++) {

								turnInfos[parser.getAttributeLocalName(i)] = parser.getAttributeValue(i)

							}

							currentTime = turnInfos["startTime"]

							super.processStartElement();

						} else if (localname.equals("Sync")) {

							currentTime = parser.getAttributeValue(null, "time")

							super.processStartElement();

						} else if (localname.equals("w")) {

							// store values

							inW = true;

							wInfos.clear()

							for (int i = 0 ; i < parser.getAttributeCount() ; i++) {

								wInfos[parser.getAttributeLocalName(i)] = parser.getAttributeValue(i)

							}

							String time = parser.getAttributeValue(null, "time")

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

								currentTime = time

							}

							wordBuffer.setLength(0);

							return; // write w later

						}

						else {

							super.processStartElement();

						}

					}

					@Override

					protected void processCharacters() throws XMLStreamException {

						if (inW) {

							wordBuffer.append(parser.getText())

						}

						else {

							super.processCharacters();

						}

					}

					@Override

					protected void processEndElement() throws XMLStreamException {

						if (localname.equals("w")) {

							inW = false

							String word = wordBuffer.toString().trim()

							if (!other && word.startsWith("*")) {

								//close current Turn and start a 'other' Turn

								writer.writeEndElement() // current Turn

								writer.writeCharacters("\n")

								def tmpInfos = new LinkedHashMap()

								for (String attr : turnInfos.keySet()) tmpInfos[attr] = turnInfos[attr]

								tmpInfos["orig-speaker"] = turnInfos["speaker"]

								tmpInfos["speaker"] = "other"

								tmpInfos["startTime"] = currentTime

								writer.writeStartElement("Turn")

								for (String attr : tmpInfos.keySet()) {

									writer.writeAttribute(attr, tmpInfos[attr])

								}

								other = true

								word = word.substring(1)

							}

							boolean shouldCloseOtherTurn = false;

							if (other && word.endsWith("*")) {

								shouldCloseOtherTurn = true;

								word = word.substring(0, word.length()-1)

								other = false

							}

							if ("XXX".equals(word)) { // <Event desc="XXX" type="unknown" extent="next"/>

								writer.writeStartElement("event") // start the initial word

								writer.writeAttribute("desc", "XXX from "+wInfos["start"] + " to "+wInfos["end"])

								writer.writeAttribute("type", "unknown")

								writer.writeAttribute("extent", "instantaneous")

								writer.writeEndElement() // event

								word = "" // don't write the word

							}

							if (word.length() > 0) {

								writer.writeStartElement("w") // start the initial word

								for (String attr : wInfos.keySet() ) {

									writer.writeAttribute(attr, wInfos[attr])

								}

								writer.writeCharacters(word)

								writer.writeEndElement() // w

							}

							if (shouldCloseOtherTurn) {

								shouldCloseOtherTurn = false;

								//close the current 'other' Turn and restart the actual Turn

								writer.writeEndElement() // current 'other' Turn

								writer.writeStartElement("Turn") // rebuild the orig Turn and fix its start-end infos

								turnInfos["startTime"] = wInfos["end"] // fix the startTime using the current word end time

								for (String attr : turnInfos.keySet()) {

									writer.writeAttribute(attr, turnInfos[attr])

								}

								other = false

							}

						} else {

							super.processEndElement();

						}

					}

				}

	}

	public static void main(String[] args) {

		File infile = new File("/home/mdecorde/xml/vocapia","test.trs")

		File outfile = new File("/home/mdecorde/xml/vocapia","test-fixed.trs")

		def processor = new FixTranscription(infile, true)

		println processor.process(outfile)

	}

}

		pages << [htmlFile, wordid] // add the last page (no pb encountered)

		return pages.size() >= 1

		File txmFile = new File(System.getProperty("user.home"), "TXM/corpora/BVHEPISTEMON2016/txm/BVHEPISTEMON2016/1546_RabelaisTL.xml")