Added fixes on ssj500k functionality, fixed prefix/suffix bug and some other bugs.

src/main/java/data/CalculateFor.java

@@ -45,72 +45,218 @@ public enum CalculateFor {
 		return null;
 	}
 
-	public String toMetadataString() {
+	public String totalSumString(int ngram) {
+		if (ngram == 0) {
+			switch (this) {
+				case WORD:
+					return "Skupna vsota vseh črkovnih nizov različnic:";
+				case NORMALIZED_WORD:
+					return "Skupna vsota vseh črkovnih nizov normaliziranih različnic:";
+				case LEMMA:
+					return "Skupna vsota vseh črkovnih nizov lem:";
+				case MORPHOSYNTACTIC_SPECS:
+					return "Skupna vsota vseh črkovnih nizov oblikoskladenjskih oznak:";
+				case MORPHOSYNTACTIC_PROPERTY:
+					return "Skupna vsota vseh črkovnih nizov oblikoskladenjskih lastnosti:";
+				case WORD_TYPE:
+					return "Skupna vsota vseh črkovnih nizov besednih vrst:";
+				case DIST_WORDS:
+					return "Skupna vsota vseh črkovnih nizov različnic:";
+				case DIST_LEMMAS:
+					return "Skupna vsota vseh črkovnih nizov lem:";
+				default:
+					return null;
+			}
+		} else if (ngram >= 1) {
+			switch (this) {
+				case WORD:
+					return "Skupna vsota vseh različnic:";
+				case NORMALIZED_WORD:
+					return "Skupna vsota vseh normaliziranih različnic:";
+				case LEMMA:
+					return "Skupna vsota vseh lem:";
+				case MORPHOSYNTACTIC_SPECS:
+					return "Skupna vsota vseh oblikoskladenjskih oznak:";
+				case MORPHOSYNTACTIC_PROPERTY:
+					return "Skupna vsota vseh oblikoskladenjskih lastnosti:";
+				case WORD_TYPE:
+					return "Skupna vsota vseh besednih vrst:";
+				case DIST_WORDS:
+					return "Skupna vsota vseh različnic:";
+				case DIST_LEMMAS:
+					return "Skupna vsota vseh lem:";
+				default:
+					return null;
+			}
+		}
+		return null;
+	}
+
+	public String foundSumString(int ngram) {
+		if (ngram == 0) {
+			switch (this) {
+				case WORD:
+					return "Skupna vsota vseh najdenih črkovnih nizov različnic:";
+				case NORMALIZED_WORD:
+					return "Skupna vsota vseh najdenih črkovnih nizov normaliziranih različnic:";
+				case LEMMA:
+					return "Skupna vsota vseh najdenih črkovnih nizov lem:";
+				case MORPHOSYNTACTIC_SPECS:
+					return "Skupna vsota vseh najdenih črkovnih nizov oblikoskladenjskih oznak:";
+				case MORPHOSYNTACTIC_PROPERTY:
+					return "Skupna vsota vseh najdenih črkovnih nizov oblikoskladenjskih lastnosti:";
+				case WORD_TYPE:
+					return "Skupna vsota vseh najdenih črkovnih nizov besednih vrst:";
+				case DIST_WORDS:
+					return "Skupna vsota vseh najdenih črkovnih nizov različnic:";
+				case DIST_LEMMAS:
+					return "Skupna vsota vseh najdenih črkovnih nizov lem:";
+				default:
+					return null;
+			}
+		} else if (ngram >= 1) {
+			switch (this) {
+				case WORD:
+					return "Skupna vsota vseh najdenih različnic:";
+				case NORMALIZED_WORD:
+					return "Skupna vsota vseh najdenih normaliziranih različnic:";
+				case LEMMA:
+					return "Skupna vsota vseh najdenih lem:";
+				case MORPHOSYNTACTIC_SPECS:
+					return "Skupna vsota vseh najdenih oblikoskladenjskih oznak:";
+				case MORPHOSYNTACTIC_PROPERTY:
+					return "Skupna vsota vseh najdenih oblikoskladenjskih lastnosti:";
+				case WORD_TYPE:
+					return "Skupna vsota vseh najdenih besednih vrst:";
+				case DIST_WORDS:
+					return "Skupna vsota vseh najdenih različnic:";
+				case DIST_LEMMAS:
+					return "Skupna vsota vseh najdenih lem:";
+				default:
+					return null;
+			}
+		}
+
+		return null;
+	}
+
+	public String totalAbsoluteFrequencyString(int ngram) {
+		if (ngram == 0) {
+			return "Skupna absolutna pogostost črkovnega niza";
+		}
 		switch(this){
 			case WORD:
-				return "Skupna vsota vseh različnic:";
+				return "Skupna absolutna pogostost različnice";
 			case NORMALIZED_WORD:
-				return "Skupna vsota vseh normaliziranih različnic:";
+				return "Skupna absolutna pogostost normalizirane različnice";
 			case LEMMA:
-				return "Skupna vsota vseh lem:";
+				return "Skupna absolutna pogostost leme";
 			case MORPHOSYNTACTIC_SPECS:
-				return "Skupna vsota vseh oblikoskladenjskih oznak:";
+				return "Skupna absolutna pogostost oblikoskladenjske oznake";
 			case MORPHOSYNTACTIC_PROPERTY:
-				return "Skupna vsota vseh oblikoskladenjskih lastnosti:";
+				return "Skupna absolutna pogostost oblikoskladenjske lastnosti";
 			case WORD_TYPE:
-				return "Skupna vsota vseh besednih vrst:";
+				return "Skupna absolutna pogostost besedne vrste";
 			case DIST_WORDS:
-				return "Skupna vsota vseh različnic:";
+				return "Skupna absolutna pogostost različnice";
 			case DIST_LEMMAS:
-				return "Skupna vsota vseh lem:";
+				return "Skupna absolutna pogostost leme";
 			default:
 				return null;
 		}
 	}
 
-	public String toHeaderString() {
+	public String shareOfTotalString(int ngram) {
+		if (ngram == 0) {
+			return "Delež glede na skupno vsoto vseh najdenih črkovnih nizov";
+		}
 		switch(this){
 			case WORD:
-				return "Različnica";
+				return "Delež glede na vse najdene različnice";
 			case NORMALIZED_WORD:
-				return "Normalizirana različnica";
+				return "Delež glede na vse najdene normalizirane različnice";
 			case LEMMA:
-				return "Lema";
+				return "Delež glede na vse najdene leme";
 			case MORPHOSYNTACTIC_SPECS:
-				return "Oblikoskladenjska oznaka";
+				return "Delež glede na vse najdene oblikoskladenjske oznake";
 			case MORPHOSYNTACTIC_PROPERTY:
-				return "Oblikoskladenjska lastnost";
+				return "Delež glede na vse najdene oblikoskladenjske lastnosti";
 			case WORD_TYPE:
-				return "Besedna vrsta";
+				return "Delež glede na vse najdene besedne vrste";
 			case DIST_WORDS:
-				return "Različnica";
+				return "Delež glede na vse najdene različnice";
 			case DIST_LEMMAS:
-				return "Lema";
+				return "Delež glede na vse najdene leme";
 			default:
 				return null;
 		}
 	}
 
-    public String toPercentString() {
-        switch(this){
-            case WORD:
-                return "Delež glede na vse različnice";
-            case NORMALIZED_WORD:
-                return "Delež glede na vse normalizirane različnice";
-            case LEMMA:
-                return "Delež glede na vse leme";
-            case MORPHOSYNTACTIC_SPECS:
-                return "Delež glede na vse oblikoskladenjske oznake";
-            case MORPHOSYNTACTIC_PROPERTY:
-                return "Delež glede na vse oblikoskladenjske lastnosti";
-            case WORD_TYPE:
-                return "Delež glede na vse besedne vrste";
-            case DIST_WORDS:
-                return "Delež glede na vse različnice";
-            case DIST_LEMMAS:
-                return "Delež glede na vse leme";
-            default:
-                return null;
-        }
-    }
+	public String toHeaderString(int ngram) {
+		if (ngram == 0) {
+			return "Črkovni niz";
+		} else if (ngram == 1) {
+			switch (this) {
+				case WORD:
+					return "Različnica";
+				case NORMALIZED_WORD:
+					return "Normalizirana različnica";
+				case LEMMA:
+					return "Lema";
+				case MORPHOSYNTACTIC_SPECS:
+					return "Oblikoskladenjska oznaka";
+				case MORPHOSYNTACTIC_PROPERTY:
+					return "Oblikoskladenjska lastnost";
+				case WORD_TYPE:
+					return "Besedna vrsta";
+				case DIST_WORDS:
+					return "Različnica";
+				case DIST_LEMMAS:
+					return "Lema";
+				default:
+					return null;
+			}
+		}
+		switch (this) {
+			case WORD:
+			case DIST_WORDS:
+				return "Različnica niza";
+			case NORMALIZED_WORD:
+				return "Normalizirana različnica niza";
+			case LEMMA:
+			case DIST_LEMMAS:
+				return "Lema niza";
+			case MORPHOSYNTACTIC_SPECS:
+				return "Oblikoskladenjska oznaka niza";
+			case MORPHOSYNTACTIC_PROPERTY:
+				return "Oblikoskladenjska lastnost niza";
+			case WORD_TYPE:
+				return "Besedna vrsta niza";
+			default:
+				return null;
+		}
+	}
+
+//    public String toPercentString() {
+//        switch(this){
+//            case WORD:
+//                return "Delež glede na vse različnice";
+//            case NORMALIZED_WORD:
+//                return "Delež glede na vse normalizirane različnice";
+//            case LEMMA:
+//                return "Delež glede na vse leme";
+//            case MORPHOSYNTACTIC_SPECS:
+//                return "Delež glede na vse oblikoskladenjske oznake";
+//            case MORPHOSYNTACTIC_PROPERTY:
+//                return "Delež glede na vse oblikoskladenjske lastnosti";
+//            case WORD_TYPE:
+//                return "Delež glede na vse besedne vrste";
+//            case DIST_WORDS:
+//                return "Delež glede na vse različnice";
+//            case DIST_LEMMAS:
+//                return "Delež glede na vse leme";
+//            default:
+//                return null;
+//        }
+//    }
 }

src/main/java/data/StatisticsNew.java

@@ -10,6 +10,7 @@ import java.util.*;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.atomic.AtomicLong;
 import java.util.regex.Pattern;
+import java.util.stream.Collectors;
 
 import org.apache.commons.lang3.StringUtils;
 import org.apache.commons.lang3.tuple.ImmutablePair;
@@ -59,7 +60,7 @@ public class StatisticsNew {
 		if (this.corpus.getTaxonomy() != null && filter.getDisplayTaxonomy()) {
 			if (this.filter.getTaxonomy().isEmpty()) {
 				for (int i = 0; i < this.corpus.getTaxonomy().size(); i++) {
-					this.taxonomyResult.put(Taxonomy.factory(this.corpus.getTaxonomy().get(i)), new ConcurrentHashMap<>());
+					this.taxonomyResult.put(Taxonomy.factoryLongName(this.corpus.getTaxonomy().get(i)), new ConcurrentHashMap<>());
 				}
 			} else {
 				for (int i = 0; i < this.filter.getTaxonomy().size(); i++) {
@@ -236,7 +237,7 @@ public class StatisticsNew {
 			analysisProducedResults = true;
 		}
 
-		removeMinimalOccurrences(taxonomyResult.get(Taxonomy.TOTAL), filter.getMinimalOccurrences());
+		removeMinimalOccurrences(filter.getMinimalOccurrences());
 		removeMinimalTaxonomy(taxonomyResult, filter.getMinimalTaxonomy());
 		stats.add(ImmutablePair.of(resultTitle, getSortedResult(taxonomyResult.get(Taxonomy.TOTAL), Util.getValidInt(limit))));
 		Export.SetToCSV(stats, corpus.getChosenResultsLocation(), headerInfoBlock(), this, filter);
@@ -265,12 +266,14 @@ public class StatisticsNew {
 	/**
 	 * Removes lines where total number of occurrences is lower than specified number (minimalOccurrences)
 	 */
-	private void removeMinimalOccurrences(Map<MultipleHMKeys, AtomicLong> taxonomyResultTotal, Integer minimalOccurrences) {
+	private void removeMinimalOccurrences(Integer minimalOccurrences) {
 		if (minimalOccurrences == 0)
 			return;
-		for (MultipleHMKeys key : taxonomyResultTotal.keySet()){
-			if(taxonomyResultTotal.get(key).intValue() < minimalOccurrences){
-				taxonomyResultTotal.remove(key);
+		for (MultipleHMKeys key : taxonomyResult.get(Taxonomy.TOTAL).keySet()){
+			if(taxonomyResult.get(Taxonomy.TOTAL).get(key).intValue() < minimalOccurrences){
+				for (Taxonomy t : taxonomyResult.keySet()){
+					taxonomyResult.get(t).remove(key);
+				}
 			}
 		}
 	}
@@ -498,15 +501,17 @@ public class StatisticsNew {
 		info.put("Izračunaj za:", filter.getCalculateFor().toString());
 
 		// also write
-		if (filter.getMultipleKeys().size() > 0){
+		if (ngramLevel > 0) {
+			if (filter.getMultipleKeys().size() > 0) {
 
-			StringBuilder mk = new StringBuilder();
-			for (CalculateFor s : filter.getMultipleKeys()) {
-				mk.append(s.toString()).append("; ");
+				StringBuilder mk = new StringBuilder();
+				for (CalculateFor s : filter.getMultipleKeys()) {
+					mk.append(s.toString()).append("; ");
+				}
+				info.put("Upoštevaj tudi: ", String.join("; ", mk.substring(0, mk.length() - 2)));
+			} else {
+				info.put("Upoštevaj tudi: ", "");
 			}
-			info.put("Izpiši tudi: ", String.join("; ", mk.substring(0, mk.length() - 2)));
-		} else {
-			info.put("Izpiši tudi: ", "");
 		}
 
 		// data limitations
@@ -535,14 +540,16 @@ public class StatisticsNew {
 		}
 
 		// also write - n - gram > 1
-		if (ngramLevel > 1 && filter.getCollocability().size() > 0){
-			StringBuilder mk = new StringBuilder();
-			for (Collocability s : filter.getCollocability()) {
-				mk.append(s.toString()).append("; ");
+		if(ngramLevel > 1) {
+			if (filter.getCollocability().size() > 0) {
+				StringBuilder mk = new StringBuilder();
+				for (Collocability s : filter.getCollocability()) {
+					mk.append(s.toString()).append("; ");
+				}
+				info.put("Kolokabilnost: ", String.join("; ", mk.substring(0, mk.length() - 2)));
+			} else {
+				info.put("Kolokabilnost: ", "");
 			}
-			info.put("Kolokabilnost: ", String.join("; ", mk.substring(0, mk.length() - 2)));
-		} else {
-			info.put("Kolokabilnost: ", "");
 		}
 
 		// fragmented MSD - n-gram = 1
@@ -580,13 +587,48 @@ public class StatisticsNew {
 //		}
 
 		info.put("Taksonomija: ", "");
-		if (isNotEmpty(filter.getTaxonomy()) && Tax.getCorpusTypesWithTaxonomy().contains(corpus.getCorpusType())) {
+		if (isNotEmpty(filter.getTaxonomy()) && Tax.getCorpusTypesWithTaxonomy().contains(corpus.getCorpusType()) || filter.getDisplayTaxonomy()) {
 			ArrayList<String> tax = Tax.getTaxonomyForInfo(corpus.getCorpusType(), filter.getTaxonomy());
 
-			String sep = "";
-			for (String s : tax) {
-				info.put(sep = sep + " ", s);
+			if (filter.getDisplayTaxonomy() && tax.size() == 0) {
+
+
+//				ArrayList<String> intList = (new ArrayList<>(taxonomyResult.keySet()).stream()
+//						.forEach(x -> {x.toString();}));
+//				ArrayList<String> taxonomyString = new ArrayList<>();
+//				for (Taxonomy t : taxonomyResult.keySet()){
+//					taxonomyString.add(t.toString());
+//				}
+//				ObservableList<String> taxonomyObservableString = Tax.getTaxonomyForComboBox(corpus.getCorpusType(), new HashSet<>(taxonomyString));
+//				ArrayList<String> sortedTaxonomyString = new ArrayList<>();
+//				for (String t : taxonomyObservableString){
+//					sortedTaxonomyString.add(t);
+//				}
+//				getTaxonomyForTaxonomyResult
+				tax = Tax.getTaxonomyForTaxonomyResult(corpus.getCorpusType(), taxonomyResult.keySet());
 			}
+
+//			String sep = "";
+			for (String s : tax) {
+
+				if (s == null) {
+					continue;
+				}
+
+//				info.put(sep = sep + " ", s);
+				if (uniGramTaxonomyOccurrences.get(Taxonomy.factoryLongName(s)) == null) {
+					info.put(s, "");
+					continue;
+				}
+				int n = uniGramTaxonomyOccurrences.get(Taxonomy.factoryLongName(s)).intValue();
+				if (n == 0) {
+					info.put(s, "");
+				} else {
+					info.put(s, String.valueOf(n));
+				}
+
+			}
+
 		}
 
 		info.put("Min. št. pojavitev: ", String.valueOf(filter.getMinimalOccurrences()));

src/main/java/data/Tax.java

@@ -135,6 +135,60 @@ public class Tax {
 		return FXCollections.observableArrayList(taxForCombo);
 	}
 
+	/**
+	 * Returns taxonomy names only for items found in headers
+	 */
+	public static ArrayList<String> getTaxonomyForTaxonomyResult(CorpusType corpusType, Set<Taxonomy> foundTax) {
+		LinkedHashMap<String, String> tax = new LinkedHashMap<>();
+		Set<Taxonomy> foundTaxHS= new HashSet<>(foundTax);
+
+		if (corpusType == CorpusType.GIGAFIDA || corpusType == CorpusType.CCKRES || corpusType == CorpusType.SSJ500K) {
+			tax = GIGAFIDA_TAXONOMY;
+		} else if (corpusType == CorpusType.GOS) {
+			tax = GOS_TAXONOMY;
+		}
+
+		ArrayList<String> taxForCombo = new ArrayList<>();
+
+		// adds parents taxonomy as well
+		Set<Taxonomy> genFoundTax = new HashSet<>();
+
+		for(Taxonomy e : foundTaxHS){
+			String[] elList = e.toString().split("\\.");
+			for(int i = 1; i < elList.length - 1; i++){
+				Taxonomy candidate = Taxonomy.factory(String.join(".", Arrays.copyOfRange(elList, 0, elList.length - i)));
+				genFoundTax.add(candidate);
+			}
+		}
+
+
+
+
+//		ArrayList<String> taxonomyString = new ArrayList<>();
+//		for (Taxonomy t : taxonomyResult.keySet()){
+//			taxonomyString.add(t.toString());
+//		}
+//		ObservableList<String> taxonomyObservableString = Tax.getTaxonomyForComboBox(corpus.getCorpusType(), new HashSet<>(taxonomyString));
+//		ArrayList<String> sortedTaxonomyString = new ArrayList<>();
+//		for (String t : taxonomyObservableString){
+//			sortedTaxonomyString.add(t);
+//		}
+
+
+
+
+		foundTaxHS.addAll(genFoundTax);
+
+		// assures same relative order
+		for (String t : tax.keySet()) {
+			if (foundTaxHS.contains(Taxonomy.factory(t))) {
+				taxForCombo.add(tax.get(t));
+			}
+		}
+
+		return taxForCombo;
+	}
+
 	public static HashSet<CorpusType> getCorpusTypesWithTaxonomy() {
 		return corpusTypesWithTaxonomy;
 	}
@@ -204,7 +258,7 @@ public class Tax {
 	public static ArrayList<String> getTaxonomyForInfo(CorpusType corpusType, ArrayList<Taxonomy> taxonomy) {
 		LinkedHashMap<String, String> tax = new LinkedHashMap<>();
 
-		if (corpusType == CorpusType.GIGAFIDA || corpusType == CorpusType.CCKRES) {
+		if (corpusType == CorpusType.GIGAFIDA || corpusType == CorpusType.CCKRES || corpusType == CorpusType.SSJ500K) {
 			tax = GIGAFIDA_TAXONOMY;
 		} else if (corpusType == CorpusType.GOS) {
 			tax = GOS_TAXONOMY;

src/main/java/data/Taxonomy.java

@@ -502,6 +502,7 @@ public enum Taxonomy {
 			r.add(SITUACIJA_TELEVIZIJA);
 		} else if(disjointTaxonomy.equals(KANAL)){
 			r.add(KANAL_OSEBNI_STIK);
+			r.add(KANAL_TELEFON);
 			r.add(KANAL_RADIO);
 			r.add(KANAL_TELEVIZIJA);
 		} else if(disjointTaxonomy.equals(SSJ_TISK)){
@@ -646,6 +647,9 @@ public enum Taxonomy {
 		connections.put(SSJ_KNJIZNO, SSJ_TISK);
 		connections.put(SSJ_LEPOSLOVNO, SSJ_KNJIZNO);
 		connections.put(SSJ_STROKOVNO, SSJ_KNJIZNO);
+		connections.put(SSJ_PERIODICNO, SSJ_TISK);
+		connections.put(SSJ_CASOPIS, SSJ_PERIODICNO);
+		connections.put(SSJ_REVIJA, SSJ_PERIODICNO);
 		connections.put(SSJ_DRUGO, SSJ_TISK);
 
 		connections.put(FT_P_GOVORNI, FT_P_PRENOSNIK);