First push.

Entire IMGazetteer Java project.

IMGazetteer/.classpath

+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.USER_LIBRARY/GATE"/>
+	<classpathentry kind="lib" path="E:/workspace/libraries/apache_log4j_1_2_17/log4j-1.2.17.jar"/>
+	<classpathentry kind="lib" path="E:/Programas/GATE/plugins/InexactGazetteer/lib/lucene-suggest-5.2.1.jar"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>

IMGazetteer/.project

+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>IMGazetteer</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>

IMGazetteer/.settings/.project

+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>.settings</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+	</buildSpec>
+	<natures>
+	</natures>
+</projectDescription>

IMGazetteer/.settings/org.eclipse.jdt.core.prefs

+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8
+org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
+org.eclipse.jdt.core.compiler.compliance=1.8
+org.eclipse.jdt.core.compiler.debug.lineNumber=generate
+org.eclipse.jdt.core.compiler.debug.localVariable=generate
+org.eclipse.jdt.core.compiler.debug.sourceFile=generate
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.source=1.8

IMGazetteer/.settings/org.eclipse.ltk.core.refactoring.prefs

+eclipse.preferences.version=1
+org.eclipse.ltk.core.refactoring.enable.project.refactoring.history=false

IMGazetteer/bin/.gitignore

+/br/

IMGazetteer/creole.xml

+<?xml version="1.0"?>
+<CREOLE-DIRECTORY 
+  ID="com.jpetrak.StringAnnotation" 
+  VERSION="3.5" 
+  DESCRIPTION="Extended Gazetteer, Java Regular Expression Annotator"
+  HELPURL="http://github.com/johann-petrak/gateplugin-stringannotation/wiki"
+>
+  <JAR scan="true">StringAnnotation.jar</JAR>
+  <JAR>lib/commons-cli-1.2.jar</JAR>
+  <JAR>lib/fastutil-6.5.4.jar</JAR>
+  <JAR>lib/commons-io-2.4.jar</JAR>
+  <JAR>lib/snakeyaml-1.11.jar</JAR>
+  <JAR>lib/commons-lang3-3.2.1.jar</JAR>  
+</CREOLE-DIRECTORY>

IMGazetteer/src/br/ufpr/inf/junior/imgazetteer/AuxiliarStringSimilarity.java

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package br.ufpr.inf.junior.imgazetteer;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.logging.Logger;
+
+import gate.creole.ExecutionException;
+
+/**
+ *
+ * @author Junior
+ */
+public class AuxiliarStringSimilarity {
+
+	protected Logger logger;
+
+	private void publi() {
+		logger = Logger.getLogger(this.getClass().getName());
+	}
+
+	/**
+	 * Define the similarity between entries and text chunks that were
+	 * associated by Edit Distance search.
+	 *
+	 * @param editDistanceResult
+	 * @param metodoComparacao
+	 * @param obj
+	 * @param similaridadeMinima
+	 * @param qtdeSimilaridadesAceitas
+	 * @param caseSensitive
+	 * @return ArrayList
+	 * @throws ExecutionException
+	 */
+	public ArrayList<SimilarityResult> secondMatch(EditDistanceResult editDistanceResult, Method metodoComparacao,
+			Object obj, float similaridadeMinima, int qtdeSimilaridadesAceitas, boolean caseSensitive)
+			throws ExecutionException {
+		List<NodeFT> listActivateLeaves = editDistanceResult.getListActivateLeaves();
+		InputString stringRead = editDistanceResult.getStringRead();
+		float similaridade;
+		float[] similaridadesValidas = new float[qtdeSimilaridadesAceitas];
+		HashMap<Float, ArrayList<SimilarityResult>> resultadosPorSimilaridade = new HashMap<>();
+		ArrayList<SimilarityResult> similarityResultsReturn = new ArrayList<>();
+
+		// Define a menor similaridade aceita para o limite de similaridades
+		// diferentes definido.
+		// IF que seleciona os melhores resultados.
+		float menorSimilaridadeAtual;
+		int qtdeSimilaridadesDiferentes;
+		if (qtdeSimilaridadesAceitas > 1) {
+			menorSimilaridadeAtual = 2;
+			qtdeSimilaridadesDiferentes = 0;
+		} else {
+			menorSimilaridadeAtual = 0;
+			qtdeSimilaridadesDiferentes = 1;
+		}
+
+		try {
+			if (listActivateLeaves != null && !listActivateLeaves.isEmpty()) {
+				// Percorre a lista de folhas ativas.
+				for (NodeFT activateLeaf : listActivateLeaves) {
+					// Percorre a lista de entradas de uma determinada folha.
+					for (Entry e : activateLeaf.getEntries()) {
+						// Verifica se a similaridade deve ser case-sensitive.
+						if (caseSensitive) {
+							similaridade = secondSimilarityMetric(e.getEntry(), stringRead.getStringBuffer().toString(),
+									metodoComparacao, obj);
+
+						} else {
+							similaridade = secondSimilarityMetric(e.getEntry().toUpperCase(),
+									stringRead.getStringBuffer().toString().toUpperCase(), metodoComparacao, obj);
+						}
+
+						// Se a similaridade for maior que a mnima definida ela
+						//  aceita.
+						if (similaridade > similaridadeMinima) {
+							if (qtdeSimilaridadesAceitas > 1) {
+								// Similaridade menor que a menor similaridade
+								// atualmente aceita.
+								if (qtdeSimilaridadesDiferentes < qtdeSimilaridadesAceitas
+										&& similaridade < menorSimilaridadeAtual) {
+									ArrayList<SimilarityResult> srTemp = new ArrayList<>();
+									srTemp.add(new SimilarityResult(e, similaridade, activateLeaf.getEDValue()));
+									similaridadesValidas[qtdeSimilaridadesDiferentes] = similaridade;
+									resultadosPorSimilaridade.put(similaridade, srTemp);
+									menorSimilaridadeAtual = similaridade;
+									qtdeSimilaridadesDiferentes++;
+									// Similaridade maior que a menor
+									// similaridade atualmente aceita.
+								} else if (similaridade > menorSimilaridadeAtual) {
+									// Similaridade j presente entre as
+									// similaridades aceitas.
+									if (resultadosPorSimilaridade.containsKey(similaridade)) {
+										ArrayList<SimilarityResult> srTemp = new ArrayList<>();
+										srTemp = resultadosPorSimilaridade.get(similaridade);
+										srTemp.add(new SimilarityResult(e, similaridade, activateLeaf.getEDValue()));
+										resultadosPorSimilaridade.put(similaridade, srTemp);
+									} else {// Similaridade não presente entre
+											// as similaridades aceitas.
+										if (qtdeSimilaridadesDiferentes == qtdeSimilaridadesAceitas) {
+											resultadosPorSimilaridade
+													.remove(similaridadesValidas[qtdeSimilaridadesAceitas - 1]);
+											for (int i = 0; i < qtdeSimilaridadesAceitas; i++) {
+												if (similaridade > similaridadesValidas[i]) {
+													for (int j = (qtdeSimilaridadesAceitas - 2); j >= i; j--) {
+														similaridadesValidas[j + 1] = similaridadesValidas[j];
+													}
+													similaridadesValidas[i] = similaridade;
+													break;
+												}
+											}
+										} else {
+											qtdeSimilaridadesDiferentes++;
+											for (int i = 0; i < qtdeSimilaridadesDiferentes; i++) {
+												if (similaridade > similaridadesValidas[i]) {
+													for (int j = (qtdeSimilaridadesDiferentes - 2); j >= i; j--) {
+														similaridadesValidas[j + 1] = similaridadesValidas[j];
+													}
+													similaridadesValidas[i] = similaridade;
+													break;
+												}
+											}
+										}
+										ArrayList<SimilarityResult> srTemp = new ArrayList<>();
+										srTemp.add(new SimilarityResult(e, similaridade, activateLeaf.getEDValue()));
+										resultadosPorSimilaridade.put(similaridade, srTemp);
+										menorSimilaridadeAtual = similaridadesValidas[qtdeSimilaridadesDiferentes - 1];
+									}
+								} else if (similaridade == menorSimilaridadeAtual) {
+									ArrayList<SimilarityResult> srTemp = new ArrayList<>();
+									srTemp = resultadosPorSimilaridade.get(similaridade);
+									srTemp.add(new SimilarityResult(e, similaridade, activateLeaf.getEDValue()));
+									resultadosPorSimilaridade.put(similaridade, srTemp);
+								}
+							} else {// Se for aceita apenas a melhor associao
+									// para cada parte do texto.
+								if (similaridade < menorSimilaridadeAtual) {
+									// Only to avoid execute other two ifs.
+								} else if (similaridade > menorSimilaridadeAtual) {
+									resultadosPorSimilaridade.remove(menorSimilaridadeAtual);
+									ArrayList<SimilarityResult> srTemp = new ArrayList<>();
+									srTemp.add(new SimilarityResult(e, similaridade, activateLeaf.getEDValue()));
+									resultadosPorSimilaridade.put(similaridade, srTemp);
+									similaridadesValidas[0] = similaridade;
+									menorSimilaridadeAtual = similaridade;
+								} else if (similaridade == menorSimilaridadeAtual) {
+									ArrayList<SimilarityResult> srTemp = new ArrayList<>();
+									srTemp = resultadosPorSimilaridade.get(similaridade);
+									srTemp.add(new SimilarityResult(e, similaridade, activateLeaf.getEDValue()));
+									resultadosPorSimilaridade.put(similaridade, srTemp);
+								}
+							}
+						}
+					}
+				}
+
+				if (!resultadosPorSimilaridade.isEmpty()) {
+					for (int i = 0; i < qtdeSimilaridadesDiferentes; i++) {
+						for (SimilarityResult sr : resultadosPorSimilaridade.get(similaridadesValidas[i])) {
+							similarityResultsReturn.add(sr);
+						}
+					}
+				}
+			}
+
+			return similarityResultsReturn;
+		} catch (Exception e) {
+			logger.severe(e.getMessage());
+			throw new ExecutionException("Error in similarity definition. " + this.getClass().getName());
+		}
+	}
+
+	/**
+	 * Invoke the method to calculate
+	 * the similarity between strings.
+	 *
+	 * @param string1
+	 * @param string2
+	 * @param metodoComparacao
+	 * @param obj
+	 * @return float
+	 */
+	private float secondSimilarityMetric(String string1, String string2, Method metodoComparacao, Object obj)
+			throws ExecutionException {
+		float similarity = 0;
+		try {
+			// Execute method to obtain similarity.
+			similarity = (float) metodoComparacao.invoke(obj, string1, string2);
+
+		} catch (SecurityException | InvocationTargetException | IllegalAccessException ex) {
+			throw new ExecutionException("Error in similarity definition. " + this.getClass().getName());
+		}
+		return similarity;
+	}
+}

IMGazetteer/src/br/ufpr/inf/junior/imgazetteer/EditDistanceResult.java

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package br.ufpr.inf.junior.imgazetteer;
+
+import java.util.List;
+
+/**
+ *
+ * @author Junior
+ */
+public class EditDistanceResult {
+    private List<NodeFT> listActivateLeaves;
+    private InputString stringRead;
+
+    public EditDistanceResult(List<NodeFT> listActivateLeaves, InputString stringRead) {
+        this.listActivateLeaves = listActivateLeaves;
+        this.stringRead = stringRead;
+    }
+
+    public List<NodeFT> getListActivateLeaves() {
+        return listActivateLeaves;
+    }
+
+    public InputString getStringRead() {
+        return stringRead;
+    }
+
+}

IMGazetteer/src/br/ufpr/inf/junior/imgazetteer/Entry.java

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package br.ufpr.inf.junior.imgazetteer;
+
+/**
+ *
+ * @author Junior
+ */
+public class Entry {
+    
+    private String entry;
+
+    public Entry(String entry) {
+        this.entry = entry;
+    }
+
+    public String getEntry() {
+        return entry;
+    }
+
+    public void setEntry(String entry) {
+        this.entry = entry;
+    }
+    
+}

IMGazetteer/src/br/ufpr/inf/junior/imgazetteer/GazetteerFeature.java

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package br.ufpr.inf.junior.imgazetteer;
+
+/**
+ *
+ * @author Junior
+ */
+public class GazetteerFeature {
+    
+    private String name;
+    private String value;
+
+    public GazetteerFeature(String name, String value) {
+        this.name = name;
+        this.value = value;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public String getValue() {
+        return value;
+    }
+
+    public void setValue(String value) {
+        this.value = value;
+    }
+
+    
+}

IMGazetteer/src/br/ufpr/inf/junior/imgazetteer/InputString.java

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package br.ufpr.inf.junior.imgazetteer;
+
+/**
+ *
+ * @author Junior
+ */
+public class InputString{
+    private StringBuffer stringBuffer;//String lida do texto
+    private Integer startOffset;//Posição inicial no texto
+    private Integer endOffset;//Posição final no texto
+    private Character nextCharacter;
+
+    public InputString() {
+        this.stringBuffer = new StringBuffer();
+        this.startOffset = 0;
+        this.endOffset = 0;
+    }
+
+    public InputString(InputString inputString) {
+        this.stringBuffer = new StringBuffer( inputString.getStringBuffer().toString());
+        this.startOffset = inputString.getStartOffset();
+        this.endOffset = inputString.getEndOffset();
+        this.nextCharacter = inputString.getNextCharacter();
+    }
+    
+    
+
+    public StringBuffer getStringBuffer() {
+        return stringBuffer;
+    }
+
+    public void setStringBuffer(StringBuffer stringBuffer) {
+        this.stringBuffer = stringBuffer;
+    }
+
+    public Integer getStartOffset() {
+        return startOffset;
+    }
+
+    public void setStartOffset(Integer startIndex) {
+        this.startOffset = startIndex;
+    }
+
+    public Integer getEndOffset() {
+        return endOffset;
+    }
+
+    public void setEndOffset(Integer endIndex) {
+        this.endOffset = endIndex;
+    }
+
+    public Character getNextCharacter() {
+        return nextCharacter;
+    }
+
+    public void setNextCharacter(Character nextCharacter) {
+        this.nextCharacter = nextCharacter;
+    }
+    
+//    public void addCharacter2StringBuffer(InputString inputString, Character c){
+//        inputString.getStringBuffer().append(c);
+//    }
+//    
+//    public void addString2StringBuffer(InputString inputString, String s){
+//        inputString.getStringBuffer().append(s);
+//    }
+}

IMGazetteer/src/br/ufpr/inf/junior/imgazetteer/NodeFT.java

+/*
+ * Contém a estrutura utilizada para montar cada nó da Trie.
+ */
+package br.ufpr.inf.junior.imgazetteer;
+
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ *
+ * @author Junior
+ */
+public class NodeFT implements Serializable{
+    private Integer id;//Identificardor unico de cada nó.
+    private Character symbol;//Armazena o caracter que representa aquele nó.
+    private List<NodeFT> childs;//Child nodes.
+    private Boolean endEntrie;//Define se o nó representa o fim da entrada (true = nó folha).
+    private boolean validNode;//quando TRUE significa que o nó está a uma distância menor que a máxima aceita do último caracter lido.
+    private int EDValue;
+    private int level;//Indica o nível de profundidade do nó na árvore. O nó RAIZ tem level 0 (zero).
+    private List<Entry> entries;
+
+    
+    public NodeFT() {
+    }
+    
+    public NodeFT(Character symbol, Boolean endEntrie, List<NodeFT> listNodeFT, int level) {
+        this.symbol = symbol;
+        this.endEntrie = endEntrie;
+        this.childs = listNodeFT;
+        this.level = level;
+    }
+    
+    
+    public Character getSymbol() {
+        return symbol;
+    }
+
+    public void setSymbol(Character symbol) {
+        this.symbol = symbol;
+    }
+
+    public List<NodeFT> getChilds() {
+        return childs;
+    }
+
+    public void setChilds(List<NodeFT> listNodeFT) {
+        this.childs = listNodeFT;
+    }
+
+
+    public Boolean getEndEntrie() {
+        return endEntrie;
+    }
+
+    public void setEndEntrie(Boolean endEntrie) {
+        this.endEntrie = endEntrie;
+    }
+
+    public boolean isValidNode() {
+        return validNode;
+    }
+
+    public void setValidNode(boolean validNode) {
+        this.validNode = validNode;
+    }
+
+    public int getEDValue() {
+        return EDValue;
+    }
+
+    public void setEDValue(int EDValue) {
+        this.EDValue = EDValue;
+    }
+
+    public List<Entry> getEntries() {
+        return entries;
+    }
+
+    public void setEntries(List<Entry> entries) {
+        this.entries = entries;
+    }
+
+    public int getLevel() {
+        return level;
+    }
+
+    public void setLevel(int level) {
+        this.level = level;
+    }
+
+    public Integer getId() {
+        return id;
+    }
+
+    public void setId(Integer id) {
+        this.id = id;
+    }
+  
+    @Override
+    public boolean equals(Object obj) {
+        if (obj == null) {
+            return false;
+        }
+        if (getClass() != obj.getClass()) {
+            return false;
+        }
+        final NodeFT other = (NodeFT) obj;
+        if ((this.id == null) ? (other.id != null) : !this.id.equals(other.id)) {
+            return false;
+        }
+        return true;
+    }
+
+    public Object clone() throws CloneNotSupportedException {
+        return super.clone();
+    }
+
+    /**
+     * Add a new Entry in property entries.
+     * @param e 
+     */
+    public void addEntry(Entry e){
+        if (this.entries == null){