Statistics
| Revision:

root / tmp / org.txm.analec.rcp / src / org / txm / macro / urs / edit / Fropos2CattexMacro.groovy @ 1726

History | View | Annotate | Download (9.8 kB)

1
package org.txm.macro.urs.edit
2

    
3
import org.apache.commons.lang.*
4
import org.kohsuke.args4j.*
5
import groovy.transform.*
6
import org.txm.*
7
import org.txm.rcp.swt.widget.parameters.*
8
import org.txm.annotation.urs.*
9
import org.txm.searchengine.cqp.*
10
import org.txm.searchengine.cqp.corpus.*
11
import visuAnalec.Message.*
12
import visuAnalec.donnees.*
13
import visuAnalec.elements.*
14
import visuAnalec.vue.*
15

    
16
/*
17
Définit la catégorie grammaticale des mentions d'après le champ `frpos'
18
(tagset de TreeTagger). 
19

20
La liste des catégories grammaticales est celle de CATTEX2009
21
-- Groupes nominaux :
22
        GN.NAM (noms propres) : Henri II
23
        GN.DEF (définis) : Le roi, du roi
24
        GN.IND (indéfinis) : Un roi
25
        GN.POS (possessifs) : [Mon roi]
26
        GN.DEM (demonstratif) : Ce roi
27
        GN.NUM (numéraux) : Deux rois
28
        GN.CHECK (GN indéterminés)
29
-- Déterminants
30
        DET.POS (possessifs) : [mon] roi
31
-- Pronoms
32
        PRO.PER (personnels) : je, moi, me, on, il, etc.
33
        PRO.ADV (adverbiaux) : y, en
34
        PRO.IND (indéfinis) : tout, tous, certains, plusieurs, etc.
35
        PRO.DEM (demonstratifs) : ceci, cela, ce, ça...
36
        PRO.POS (possessifs) : le mien, les nôtres...
37
        PRO.NUM (cardinaux, ordinaux) : les deux...
38
        PRO.REL (relatifs) : qui, que, quoi, duquel, etc.
39
        PRO.INT (interrogatifs)
40
        PRO.CHECK (pronoms indéterminés)
41
-- SUJ.ZERO (Sujet Zéro) : verbes conjugués, éventuellement pronominal
42

43
-- ERREUR : erreur (a priori) de mention
44
-- ADJpos : adjectif possessif à fusionner ou pas avec DETpos
45
        
46
*/
47

    
48

    
49

    
50
def testRules(def positions, def Mention) {
51
        def catégorie = null
52
        
53
        // la forme du premier mot de la mention s'appelle 'forme'
54
        def forme = CQI.cpos2Str(word.getQualifiedName(), positions)[0].toLowerCase()
55
    
56
    
57
        if (Mention.length == 1) {    
58
            
59
                     if (Mention.first() == "NOMpro"    ) catégorie = "GN.NAM"
60
                else if (Mention.first() == "DETpos") catégorie = "DET.POS"
61
                else if (Mention.first() == "ADJpos") catégorie = "ADJ.POS"
62
                else if (Mention.first() == "PROdem") catégorie = "PRO.DEM"
63
                else if (Mention.first() == "PROind") catégorie = "PRO.IND"
64
                else if (Mention.first() == "PROcar") catégorie = "PRO.NUM"
65
                else if (Mention.first() == "PROord") catégorie = "PRO.NUM" // fusionné avec Cardinaux
66
                else if (Mention.first() == "PROpos") catégorie = "PRO.POS"
67
                else if (Mention.first() == "PROper") catégorie = "PRO.PER" 
68
                else if (Mention.first() == "PROimp") catégorie = "PRO.PER" // fusionné avec Pronoms Personnels
69
                else if (Mention.first() == "PROint") catégorie = "PRO.INT"
70
                else if (Mention.first() == "PROadv") catégorie = "PRO.ADV"
71
                else if (Mention.first() == "PROrel") catégorie = "PRO.REL"
72
                
73
                else if (Mention.first().contains("VER")) catégorie = "SUJ.ZERO"
74
                
75
                else if (Mention.first() == "NOMcom") catégorie = "GN.CHECK"
76
                
77
                // Pronoms "contractés"
78
                else if (Mention.first() == "PROper.PROper") catégorie = "PRO.PER"  // double pronom personnel : ex 'jel' pour 'je le'
79
                else if (Mention.first() == "ADVgen.PROper") catégorie = "PRO.PER"  // adverbe + pronom personnel : ex 'sil' pour 'si le'
80
                else if (Mention.first() == "ADVneg.PROper") catégorie = "PRO.PER"  // adverbe + pronom personnel : ex 'nel' pour 'ne le'
81
                
82
                // Erreurs de mention
83
                else if (Mention.first() == "ADVgen") catégorie = "ERREUR"  // un adverbe seul n'est jamais référentiel
84
                else if (Mention.first() == "ADVneg") catégorie = "ERREUR"  // un adverbe seul n'est jamais référentiel
85
                else if (Mention.first() == "PRE") catégorie = "ERREUR"  // une preposition seule n'est jamais référentielle
86
                else if (Mention.first() == "ADJqua") catégorie = "ERREUR"  // un adjectif seul n'est jamais référentiel
87
                else if (Mention.first() == "ADJind") catégorie = "ERREUR"  // un adjectif seul n'est jamais référentiel
88
                else if (Mention.first() == "INJ") catégorie = "ERREUR"  // une interjection seule n'est jamais référentielle
89
                
90
                else catégorie = "PRO.CHECK"        
91

    
92
        } else if (Mention.length == 2) {
93
                if ( (Mention[0] == "NOMpro") || (Mention[1] == "NOMpro") ) catégorie = "GN.NAM"
94
                else if (Mention[1] == "PROrel") catégorie = "PRO.REL"  // "ce que" prioritaire sur "celui là"
95
                else if (Mention[1] == "PROpos") catégorie = "PRO.POS"  // "les miens"
96
                else if (Mention[1].contains("car")) catégorie = "PRO.NUM"  // "les deux"
97
                else if (Mention[1] == "PROdem") catégorie = "PRO.DEM"  // "Tout cela"
98
                
99
                else if (Mention[0].contains("DET") && Mention[1].contains("PROind")) catégorie = "PRO.IND" // "les autres"
100
                
101
                else if (Mention[0].contains("VER") && Mention[1].contains("VER")) catégorie = "SUJ.ZERO" // verbe temps composé
102
                
103
                else if (!Mention[0].contains("NOM") && !Mention[0].contains("ADJ") && !Mention[1].contains("NOM") && !Mention[1].contains("ADJ")) {
104
                        if (Mention[0] == "PROdem") catégorie = "PRO.DEM"
105
                        else if (Mention[1] == "VERinf") catégorie = "GN.CHECK" // Verbe substantivé
106
                        else if (Mention[1] == "VERppa") catégorie = "GN.CHECK" // Verbe substantivé
107
                        else if ( Mention[0].contains("PRE") && (Mention[1] == "PROper")) catégorie = "GN.CHECK" // Complément de nom
108
                        else catégorie = "PRO.CHECK"
109
                }
110
                else catégorie = "GN.CHECK"           
111
        } 
112
        
113
        if ( (catégorie == null) || (catégorie == "GN.CHECK") ) {
114
                // on est dans les GN
115
                
116
                if (Mention[0] == "DETcar"     ) catégorie = "GN.NUM"
117
                else if (Mention[0] == "DETord"     ) catégorie = "GN.NUM"
118

    
119
                else if (Mention.contains("NOMpro")) catégorie = "GN.NAM"
120
                                
121
                else if (Mention[0] == "DETpos" ) catégorie = "GN.POS"
122
                                
123
                else if (Mention[0] == "PROdem" ) catégorie = "GN.DEM"
124
                else if (Mention[0] == "DETdem" ) catégorie = "GN.DEM"
125
                
126
                else if (Mention[0] == "PRE.DETdef" ) catégorie = "GN.DEF"
127
                else if (Mention[0] == "DETdef")   catégorie = "GN.DEF"
128
                
129
                else if (Mention[0] == "DETndf") catégorie = "GN.IND" 
130
                else if (Mention[0] == "DETind") catégorie = "GN.IND" 
131
                
132
                else if (Mention[0] == "PROind" ) catégorie = "GN.IND"
133
                else if (Mention[0].contains("PRP")) catégorie = "GN.IND"
134
                else if (Mention[0].contains("ADJ")) catégorie = "GN.IND"
135
                else if (Mention[0].contains("NOM")) catégorie = "GN.IND"
136
                
137
                
138
                
139
                else catégorie = "GN.CHECK"
140
        }
141

    
142

    
143
        
144
        return catégorie
145
}
146

    
147
//
148
// FIN DE LA DÉFINITION DES RÈGLES
149
//
150

    
151
// CORPS DU SCRIPT
152

    
153
if (!(corpusViewSelection instanceof MainCorpus)) {
154
        println "Corpora selection is not a Corpus"
155
        return
156
}
157

    
158
// BEGINNING OF PARAMETERS
159
@Field @Option(name="unit_type", usage="", widget="String", required=true, def="MENTION")
160
def unit_type
161
@Field @Option(name="pos_property_name", usage="", widget="String", required=true, def="pos")
162
def pos_property_name
163
@Field @Option(name="reset", usage="", widget="Boolean", required=true, def="true")
164
def reset
165
if (!ParametersDialog.open(this)) return
166

    
167
corpus = corpusViewSelection
168
CQI = CQPSearchEngine.getCqiClient()
169
word = corpus.getWordProperty()
170
posProperty = corpus.getProperty(pos_property_name)
171
if (posProperty == null) {
172
        println "Error: CQP corpus does not contains the word property with name=$pos_property_name"
173
        return
174
}
175
analecCorpus = URSCorpora.getCorpus(corpus)
176
vue = URSCorpora.getVue(corpus)
177
structure = analecCorpus.getStructure()
178
if (!structure.getUnites().contains(unit_type)) { // check if the structure contains the unit_type units
179
        println "Error: corpus structure does not contains unit with name=$unit_type"
180
        return
181
}
182

    
183
CATEGORIE = "CATEGORIE"
184
// Si la structure d'annotation ne contient pas CATEGORIE, on la crée avec ses valeurs
185
if (!structure.getUniteProperties(unit_type).contains(CATEGORIE)) { 
186
// la propriété
187
        analecCorpus.ajouterProp(Unite.class, unit_type, CATEGORIE)
188
// les valeurs
189
        structure.ajouterVal(Unite.class, unit_type, CATEGORIE, "GN.NAM")
190
        structure.ajouterVal(Unite.class, unit_type, CATEGORIE, "GN.DEF")
191
        structure.ajouterVal(Unite.class, unit_type, CATEGORIE, "GN.IND")
192
        structure.ajouterVal(Unite.class, unit_type, CATEGORIE, "GN.POS")
193
        structure.ajouterVal(Unite.class, unit_type, CATEGORIE, "GN.DEM")
194
        structure.ajouterVal(Unite.class, unit_type, CATEGORIE, "GN.NUM")
195
        
196
        structure.ajouterVal(Unite.class, unit_type, CATEGORIE, "GN.CHECK")
197
        
198
        structure.ajouterVal(Unite.class, unit_type, CATEGORIE, "DET.POS")
199
        
200
        structure.ajouterVal(Unite.class, unit_type, CATEGORIE, "PRO.PER")
201
        structure.ajouterVal(Unite.class, unit_type, CATEGORIE, "PRO.ADV")
202
        structure.ajouterVal(Unite.class, unit_type, CATEGORIE, "PRO.IND")
203
        structure.ajouterVal(Unite.class, unit_type, CATEGORIE, "PRO.DEM")
204
        structure.ajouterVal(Unite.class, unit_type, CATEGORIE, "PRO.POS")
205
        structure.ajouterVal(Unite.class, unit_type, CATEGORIE, "PRO.NUM")
206
        structure.ajouterVal(Unite.class, unit_type, CATEGORIE, "PRO.INT")
207
        structure.ajouterVal(Unite.class, unit_type, CATEGORIE, "PRO.REL")
208
        
209
        structure.ajouterVal(Unite.class, unit_type, CATEGORIE, "PRO.CHECK")
210
        
211
        structure.ajouterVal(Unite.class, unit_type, CATEGORIE, "SUJ.ZERO")
212
        
213
        structure.ajouterVal(Unite.class, unit_type, CATEGORIE, "ERREUR")
214
        structure.ajouterVal(Unite.class, unit_type, CATEGORIE, "ADJ.POS")
215
        
216
//...
217
}
218

    
219
def nModified = 0
220
def nIgnored = 0
221

    
222
errors = new HashMap()
223
def units = analecCorpus.getUnites(unit_type)
224
units.sort() { a, b -> a.getDeb() <=> b.getDeb() ?: a.getFin() <=> b.getFin() }
225
for (Unite unit : units) { // process all units
226
        
227
        def prop = unit.getProp(CATEGORIE)
228
        if (!reset && prop != null && prop.length() > 0) continue // l'unité a déjà une CATEGORIE
229
        
230
        int[] positions = null
231
        if (unit.getDeb() == unit.getFin()) positions = [unit.getDeb()]
232
        else positions = (unit.getDeb()..unit.getFin())
233
        
234
        def Mention = CQI.cpos2Str(posProperty.getQualifiedName(), positions)
235
        def cat = testRules(positions, Mention)
236
        
237
        if (cat != null) {
238
                vue.setValeurChamp(unit, CATEGORIE, cat)
239
                nModified++
240
        } else {
241
                nIgnored++
242
        }
243
}
244

    
245
println "Result:"
246
println "- $nModified units of type $unit_type have been modified."
247
println "- $nIgnored units of type $unit_type have not been modified.\n"
248

    
249
if (errors.size() > 0) {
250
        println "Some rules should be added to this macro to process the following remaining 'FROPOS / words' values:"
251
        errors.keySet().each { println "fropos="+it+"\twords="+errors[it].join(" | ") }
252
}