1   package eu.fbk.dh.tint.simplifier;
2   
3   import com.google.common.collect.HashMultimap;
4   import edu.stanford.nlp.ling.CoreAnnotations;
5   import edu.stanford.nlp.ling.IndexedWord;
6   import edu.stanford.nlp.pipeline.Annotation;
7   import edu.stanford.nlp.semgraph.SemanticGraph;
8   import edu.stanford.nlp.semgraph.SemanticGraphCoreAnnotations;
9   import edu.stanford.nlp.semgraph.SemanticGraphEdge;
10  import edu.stanford.nlp.util.CoreMap;
11  import eu.fbk.dh.tint.runner.TintPipeline;
12  import eu.fbk.dh.tint.simplifier.rules.ReplaceSubordinateRule;
13  import eu.fbk.dh.tint.simplifier.rules.SimplificationRule;
14  import eu.fbk.utils.corenlp.outputters.JSONOutputter;
15  
16  import java.util.*;
17  
18  /**
19   * Created by alessio on 14/02/17.
20   */
21  
22  public class Simplifier {
23  
24      public static final Integer MAX_ITER = 100;
25  
26      public static void main(String[] args) {
27          String sentenceText;
28          sentenceText = "Per gli interventi di seguito descritti, la cui autorizzazione può risultare di competenza dei Comuni o delle CTC in relazione alla tipologia ed alla localizzazione dell'intervento, si indicano i seguenti elaborati, precisando che essi sono orientativi e che comunque devono mostrare chiaramente dove si interviene e come si interviene.";
29          sentenceText = "Il mondo, precisando che si tratta della Terra, è molto bello.";
30          sentenceText = "In particolare, andranno rilevati e descritti tutti gli elementi di criticità paesaggistica, insiti nel progetto, e andranno messi in relazione a quanto è stato operato, per eliminare o mitigare tali criticità (impatti), garantendo così un migliore inserimento paesaggistico dell'intervento.";
31          sentenceText = "In funzione della tipologia dell'opera, oggetto di richiesta di autorizzazione, sono previste due forme diverse di relazione paesaggistica, denominate rispettivamente:";
32          sentenceText = "Sebbene non sappia l'inglese, si è fatto capire dai turisti.";
33  //        sentenceText = "Io cancello il gesso dalla lavagna.";
34  
35          try {
36  
37              TintPipeline pipeline = new TintPipeline();
38              pipeline.loadDefaultProperties();
39              pipeline.setProperty("annotators", "ita_toksent, udpipe, ita_morpho, ita_lemma, ita_comp_morpho");
40              pipeline.setProperty("customAnnotatorClass.udpipe", "eu.fbk.dh.fcw.udpipe.api.UDPipeAnnotator");
41              pipeline.setProperty("customAnnotatorClass.ita_comp_morpho", "eu.fbk.dh.tint.digimorph.annotator.DigiCompMorphAnnotator");
42              pipeline.setProperty("udpipe.server", "gardner");
43              pipeline.setProperty("udpipe.port", "50020");
44              pipeline.setProperty("udpipe.keepOriginal", "1");
45              pipeline.load();
46  
47              Annotation annotation = pipeline.runRaw(sentenceText);
48              System.out.println(JSONOutputter.jsonPrint(annotation));
49  
50              Map<Integer, HashMultimap<Integer, Integer>> children = new HashMap<>();
51              List<CoreMap> sentences = annotation.get(CoreAnnotations.SentencesAnnotation.class);
52              for (int sentIndex = 0; sentIndex < sentences.size(); sentIndex++) {
53                  CoreMap sentence = sentences.get(sentIndex);
54  
55                  children.put(sentIndex, HashMultimap.create());
56  
57                  SemanticGraph semanticGraph = sentence
58                          .get(SemanticGraphCoreAnnotations.BasicDependenciesAnnotation.class);
59                  Collection<IndexedWord> rootNodes = semanticGraph.getRoots();
60                  if (rootNodes.isEmpty()) {
61                      continue;
62                  }
63  
64                  for (IndexedWord root : rootNodes) {
65                      Set<Integer> stack = new HashSet<>();
66                      Set<IndexedWord> used = new HashSet<>();
67                      addChildren(children.get(sentIndex), stack, root, semanticGraph, used);
68                  }
69              }
70  
71              SimplificationRule rule;
72              String output;
73  
74              rule = new ReplaceSubordinateRule();
75              output = rule.apply(annotation, children);
76  
77              System.out.println(output);
78  
79  //            rule = new DenominatiSplittingRule();
80  //            output = rule.apply(annotation, children);
81  //
82  //            System.out.println(output);
83  //
84  //            rule = new GarantendoSplittingRule();
85  //            output = rule.apply(annotation, children);
86  //
87  //            System.out.println(output);
88  //
89  //            rule = new GarantendoSplittingRule();
90  //            output = rule.apply(annotation, children);
91  //
92  //            System.out.println(output);
93  //
94          } catch (Exception e) {
95              e.printStackTrace();
96          }
97  
98      }
99  
100     public static Set<IndexedWord> getParents(SemanticGraph semanticGraph, IndexedWord node) {
101         Set<IndexedWord> ret = new HashSet<>();
102         List<SemanticGraphEdge> incomingEdgesSorted = semanticGraph.getIncomingEdgesSorted(node);
103         if (incomingEdgesSorted.size() > 0) {
104             for (SemanticGraphEdge semanticGraphEdge : incomingEdgesSorted) {
105                 ret.add(semanticGraphEdge.getGovernor());
106             }
107         }
108         return ret;
109     }
110 
111     public static Set<IndexedWord> getChildren(SemanticGraph semanticGraph, IndexedWord node) {
112         Set<IndexedWord> ret = new HashSet<>();
113         List<SemanticGraphEdge> outEdgesSorted = semanticGraph.getOutEdgesSorted(node);
114         for (SemanticGraphEdge semanticGraphEdge : outEdgesSorted) {
115             ret.add(semanticGraphEdge.getDependent());
116         }
117         return ret;
118     }
119 
120     public static List<IndexedWord> getChildrenRecursive(SemanticGraph semanticGraph, IndexedWord indexedWord) throws Exception {
121         LinkedHashSet<IndexedWord> ret = new LinkedHashSet();
122         getChildrenRecursive(semanticGraph, indexedWord, ret, 0);
123         return new ArrayList<>(ret);
124     }
125 
126     public static void getChildrenRecursive(SemanticGraph semanticGraph, IndexedWord node, LinkedHashSet<IndexedWord> list, int iter)
127             throws Exception {
128         if (iter > MAX_ITER) {
129             throw new Exception("Too many iterations");
130         }
131         List<SemanticGraphEdge> outEdgesSorted = semanticGraph.getOutEdgesSorted(node);
132         for (SemanticGraphEdge semanticGraphEdge : outEdgesSorted) {
133             IndexedWord child = semanticGraphEdge.getDependent();
134             list.add(child);
135             getChildrenRecursive(semanticGraph, child, list, iter + 1);
136         }
137     }
138 
139     public static List<IndexedWord> getHistory(SemanticGraph semanticGraph, IndexedWord node) {
140         List<IndexedWord> ret = new ArrayList<>();
141         ret.add(node);
142         getHistory(semanticGraph, node, ret);
143         return ret;
144     }
145 
146     public static void getHistory(SemanticGraph semanticGraph, IndexedWord node, List<IndexedWord> start) {
147         List<SemanticGraphEdge> incomingEdgesSorted = semanticGraph.getIncomingEdgesSorted(node);
148         if (incomingEdgesSorted.size() > 0) {
149             IndexedWord governor = incomingEdgesSorted.get(0).getGovernor();
150             start.add(governor);
151             getHistory(semanticGraph, governor, start);
152         }
153     }
154 
155     protected static void addChildren(HashMultimap<Integer, Integer> children, Set<Integer> stack, IndexedWord current,
156             SemanticGraph semanticGraph, Set<IndexedWord> used) {
157         List<SemanticGraphEdge> edges = semanticGraph.getOutEdgesSorted(current);
158         used.add(current);
159         int index = current.index();
160 
161         for (Integer integer : stack) {
162             children.put(integer, index);
163         }
164 
165         Set<Integer> newStack = new HashSet<>(stack);
166         newStack.add(index);
167 
168         for (SemanticGraphEdge edge : edges) {
169             IndexedWord target = edge.getTarget();
170 //            String relation = edge.getRelation().toString();
171 //            if (relation.equals("punct")) {
172 //                continue;
173 //            }
174             if (!used.contains(target)) {
175                 addChildren(children, newStack, target, semanticGraph, used);
176             }
177         }
178     }
179 
180 }