-
Notifications
You must be signed in to change notification settings - Fork 0
/
CalculDistance.java
152 lines (142 loc) · 5.94 KB
/
CalculDistance.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.StringTokenizer;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.apache.commons.lang3.StringUtils;
import org.jdom2.Document;
import org.jdom2.Element;
import org.jdom2.xpath.XPathFactory;
/*
* Cette classe permet de calculer différents degrés de distance entre deux unités référentielles.
* Elle a deux accesseurs :
* -> Un premier nécessitant en paramètre un document DOM
* -> Un second sans paramètre
*
* Différentes méthodes sont utiles à chaque niveau de distance :
* -> La méthode NbAnchor calcule la distance en nombre de mentions. Elle prend en paramètre
* deux chaînes de caractères correspondant aux attributs "id" des éléments "unit" décrivant
* les deux expressions référentielles à analyser.
* Le retour de la fonction correspond au nombre de mentions séparant ces deux unités,
* que l'on obtient en soustrayant leur valeurs respectives d'attribut "num".
* -> La méthode NbTurn calcule de la même manière la distance en nombre de tour de parole.
* Les deux paramètres sont les mêmes, grâce auxquels on récupère les éléments Turn parents de
* chacune des deux unités, dont on soustrait les valeurs d'attributs "id".
* -> La méthode Count propose en sortie une liste de deux éléments, le premier correspondant au
* nombre de caractères entre deux mentions, le second à celle en nombre de mots.
* Elle prend 3 paramètres que sont deux nouveaux les deux identifiants des unités, et le fichier xml
* en tant que chaîne de caractères. Grâce à une expression régulière, on récupère tout ce qui se
* trouve entre les deux identifiants, puis on nettoie cette sortie des éléments XML. La chaîne de
* caractères finale ne contient donc que les éléments textuels compris entre les deux mentions.
* La taille de cette chaîne nous donne la distance en nombre de caractères entre ces mentions,
* puis après tokenisation, on obtient celle en nombre de mots.
*/
public class CalculDistance {
private Document document = new Document();
public CalculDistance (Document doc){
this.document = doc;
}
public CalculDistance (){
}
public int NbAnchor (String str1, String str2) throws IOException{
Element mention1 = (Element)XPathFactory.instance().compile("//anchor[@id='" +str1+"']").evaluateFirst(this.document);
Element mention2 = (Element)XPathFactory.instance().compile("//anchor[@id='" +str2+"']").evaluateFirst(this.document);
int nbAnchor = (Integer.parseInt(mention2.getAttributeValue("num")))- (Integer.parseInt(mention1.getAttributeValue("num")));
return nbAnchor;
}
public int NbTurn (String str1, String str2) throws IOException{
Element turn1 = (Element)XPathFactory.instance().compile("//anchor[@id='" +str1+"']/ancestor::Turn").evaluateFirst(this.document);
Element turn2 = (Element)XPathFactory.instance().compile("//anchor[@id='" +str2+"']/ancestor::Turn").evaluateFirst(this.document);
int nbTurn = (Integer.parseInt(turn2.getAttributeValue("id")))- (Integer.parseInt(turn1.getAttributeValue("id")));
return nbTurn;
}
public String readFileAsString(String filePath) throws java.io.IOException{
byte[] buffer = new byte[(int) new File(filePath).length()];
BufferedInputStream f = null;
try {
f = new BufferedInputStream(new FileInputStream(filePath));
f.read(buffer);
} finally {
if (f != null) try { f.close(); } catch (IOException ignored) { }
}
return new String(buffer);
}
public List<Integer> Count(String str1, String str2, String fichier) throws IOException{
List<Integer> distance = new ArrayList<Integer>();
if (this.NbAnchor(str1, str2) > 1){
Matcher searching1 = Pattern.compile(str1).matcher(fichier);
Matcher searching2 = Pattern.compile(str2).matcher(fichier);
int verif1 = 0;
int verif2 = 0;
while (verif1==0){
searching1.find();
verif1 = searching1.end();
}
while (verif2==0){
searching2.find();
verif2 = searching2.start();
}
String subPart = fichier.substring(verif1, verif2);
String copy= "";
new StringUtils();
//StringUtils str = new StringUtils();
subPart = StringUtils.strip(subPart);
Matcher text = Pattern.compile("([^\\s]+\\s?[^\\s]*)").matcher(subPart);
while (text.find()){
copy = copy + subPart.substring(text.start(),text.end())+" ";
}
int close = copy.indexOf("</anchor>");
int closeBis = close;
String i = copy.substring(close, close+19);
while (i.equals("</anchor>")){
closeBis = closeBis+19;
i = copy.substring(closeBis, closeBis+19);
}
int lastAnchor = copy.lastIndexOf("<anchor id=\"");
copy = copy.substring(closeBis, lastAnchor);
int verif = 0;
int begin = 0;
Matcher balise = Pattern.compile("<[^>]*>").matcher(copy);
while(balise.find()){
verif++;
}
while(begin<verif){
copy = this.DeleteTag(copy);
begin++;
}
List<String> listeMots = new ArrayList<String >();
StringTokenizer st = new StringTokenizer(copy);
while (st.hasMoreTokens()){
listeMots.add(st.nextToken());
}
int nbMots = 0;
int nbChar = 0;
for (String j : listeMots){
if(!j.contains("<") && !j.contains(">") && !j.contains("=") && !j.equals("\"") ){
nbMots++;
nbChar = nbChar + j.length();
}
}
distance.add(nbChar);
distance.add(nbMots);
}
else{
distance.add(0); distance.add(0);
}
return distance;
}
public String DeleteTag(String fichier){
int first = 0;
Matcher balise = Pattern.compile("<[^>]*>").matcher(fichier);
while (first==0){
balise.find();
fichier = fichier.substring(0,balise.start())+fichier.substring(balise.end(), fichier.length());
first++;
}
return fichier;
}
}