2022-06-16 16:45:48 +02:00
|
|
|
|
package evaluer;
|
2022-04-25 13:25:20 +02:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
import java.util.ArrayList;
|
|
|
|
|
import java.util.Dictionary;
|
|
|
|
|
import java.util.Hashtable;
|
|
|
|
|
import java.util.regex.Matcher;
|
|
|
|
|
import java.util.regex.Pattern;
|
|
|
|
|
|
2022-06-16 16:45:48 +02:00
|
|
|
|
import MEPTL.HTML;
|
|
|
|
|
import MEPTL.commandes;
|
2022-04-25 13:25:20 +02:00
|
|
|
|
import cXML.node;
|
2022-06-11 12:10:28 +02:00
|
|
|
|
import calcul.StringSimilarity;
|
2022-04-25 13:25:20 +02:00
|
|
|
|
/**
|
|
|
|
|
*
|
|
|
|
|
* @author pablo rodriguez
|
|
|
|
|
*
|
|
|
|
|
*/
|
2022-06-16 16:45:48 +02:00
|
|
|
|
public class evaluation {
|
2022-04-25 13:25:20 +02:00
|
|
|
|
|
|
|
|
|
public static Dictionary<String, String> traduction = new Hashtable<String, String>();
|
|
|
|
|
|
|
|
|
|
private static int pointsClass = 0;
|
|
|
|
|
private static int pointTotal=0;
|
|
|
|
|
private static int pointEnJeu = 0;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Chargement des traductions des éléments de l'exercice an utilsant le node "<b>translation</b>" du fichier d'analyse.<br>
|
|
|
|
|
* Les noms des éléments sont placés dans un dictionnaire la key et la valeur est le code HTML.
|
|
|
|
|
*
|
|
|
|
|
* @param translation Le node "<b>translation</b>" qui se trouve dans le node "<b>setting</b>" du fichier d'analyse.
|
|
|
|
|
*/
|
|
|
|
|
public static void chargeTraduction(node translation) {
|
|
|
|
|
if(translation!=null) {
|
|
|
|
|
|
|
|
|
|
String classText = "";
|
|
|
|
|
if(translation.getAttributs().get("classtext")!=null) if(!translation.getAttributs().get("classtext").isEmpty()) classText = "</span><span class=\""+ translation.getAttributs().get("classtext") +"\">";
|
|
|
|
|
|
|
|
|
|
String className = "";
|
|
|
|
|
if(translation.getAttributs().get("class")!=null) if(!translation.getAttributs().get("class").isEmpty()) className = "<div class=\"" + translation.getAttributs().get("class") + "\">";
|
|
|
|
|
|
|
|
|
|
for(int i = 0 ; i < translation.getNodes().size();i++) {
|
|
|
|
|
String translate = "";
|
|
|
|
|
String contenu ="";
|
|
|
|
|
String link = "";
|
|
|
|
|
String color = "";
|
|
|
|
|
String codeHTML = "";
|
|
|
|
|
boolean T = false;
|
|
|
|
|
|
|
|
|
|
if(translation.getNodes().get(i).getAttributs().get("translate")!=null) if(!translation.getNodes().get(i).getAttributs().get("translate").isEmpty()) translate=translation.getNodes().get(i).getAttributs().get("translate");
|
2022-05-03 16:02:02 +02:00
|
|
|
|
if(!translation.getNodes().get(i).getContenu().isEmpty()) contenu = translation.getNodes().get(i).getContenu().get(0).replace("-!", "<").replace("!-", ">");
|
2022-04-25 13:25:20 +02:00
|
|
|
|
if(translation.getNodes().get(i).getAttributs().get("link")!=null) if(!translation.getNodes().get(i).getAttributs().get("link").isEmpty()) link="<p><a href=\"" + translation.getNodes().get(i).getAttributs().get("link") + "\" target=\"_blank\">Lien</a></p>";
|
|
|
|
|
if(translation.getNodes().get(i).getAttributs().get("color")!=null) if(!translation.getNodes().get(i).getAttributs().get("color").isEmpty()) color="<span style=\"color:" + translation.getNodes().get(i).getAttributs().get("color") + "\">";
|
|
|
|
|
if(translation.getNodes().get(i).getAttributs().get("image")!=null) if(!translation.getNodes().get(i).getAttributs().get("image").isEmpty()) if(translation.getNodes().get(i).getAttributs().get("image").equals("true")) T=true;
|
|
|
|
|
|
|
|
|
|
if(!contenu.isEmpty() && !className.isEmpty() && !classText.isEmpty()) {
|
|
|
|
|
if(!link.isEmpty()) {
|
|
|
|
|
if(!color.isEmpty()) {
|
|
|
|
|
if(!T) codeHTML = className + color + translate + "</span>" + classText + contenu + link + "</span></div>" ;
|
|
|
|
|
if(T) codeHTML = className + HTML.imgInterogation() + color + translate + "</span>" + classText + contenu + link + "</span></div>" ;
|
|
|
|
|
}else {
|
|
|
|
|
if(!T) codeHTML = className + translate + "</span>" + classText + contenu + link + "</span></div>" ;
|
|
|
|
|
if(T) codeHTML = className + HTML.imgInterogation() + translate + "</span>" + classText + contenu + link + "</span></div>" ;
|
|
|
|
|
}
|
|
|
|
|
}else {
|
|
|
|
|
if(!color.isEmpty()) {
|
|
|
|
|
if(!T) codeHTML = className + color + translate + "</span>"+ classText + contenu + "</span></div>" ;
|
|
|
|
|
if(T) codeHTML = className + HTML.imgInterogation() + color + translate + "</span>"+ classText + contenu + "</span></div>" ;
|
|
|
|
|
}else {
|
|
|
|
|
if(!T) codeHTML = className + translate + classText + contenu + "</span></div>" ;
|
|
|
|
|
if(T) codeHTML = className + HTML.imgInterogation() + translate + classText + contenu + "</span></div>" ;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}else {
|
|
|
|
|
if(!link.isEmpty()) {
|
|
|
|
|
if(!color.isEmpty()) {
|
|
|
|
|
if(!T) codeHTML = color + translate+ "</span>" + link;
|
|
|
|
|
if(T) codeHTML = color + HTML.imgInterogation() + translate+ "</span>" + link;
|
|
|
|
|
}else {
|
|
|
|
|
if(!T) codeHTML = translate + link;
|
|
|
|
|
if(T) codeHTML = HTML.imgInterogation() + translate + link;
|
|
|
|
|
}
|
|
|
|
|
}else {
|
|
|
|
|
if(!color.isEmpty()) {
|
|
|
|
|
if(!T) codeHTML = color + translate+ "</span>";
|
|
|
|
|
if(T) codeHTML = color + HTML.imgInterogation() + translate+ "</span>";
|
|
|
|
|
}else {
|
|
|
|
|
if(!T) codeHTML = translate;
|
|
|
|
|
if(T) codeHTML = HTML.imgInterogation() + translate;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
codeHTML = codeHTML.replace("-!", "<").replace("!-", ">");
|
|
|
|
|
if(!codeHTML.isEmpty()) {
|
|
|
|
|
traduction.put(translation.getNodes().get(i).getNomElt().replace("..", " "),codeHTML);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Compare les chaînes de caractères A et sujet en fonction des 8 fonctions ‽ † ¢ → ¦ ↕ ↑ † ×<br>
|
|
|
|
|
*
|
|
|
|
|
* @param A le texte de l'étudiant.
|
2022-06-16 16:45:48 +02:00
|
|
|
|
* @param Sujet le texte du sujet.
|
2022-04-25 13:25:20 +02:00
|
|
|
|
* @return Une chaine de caractère contenant "Correct" ou "Erreur".
|
|
|
|
|
*/
|
|
|
|
|
public static String Compare(String A, String Sujet ) {
|
|
|
|
|
|
|
|
|
|
// les points
|
|
|
|
|
String pointString = "" ;
|
|
|
|
|
pointEnJeu=0;
|
|
|
|
|
if(Sujet!=null) if(Sujet.contains("‽")) {
|
|
|
|
|
pointString = TraitePoint(Sujet);
|
|
|
|
|
Sujet=Sujet.substring(0, Sujet.indexOf("‽"));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// optionnel pas d'analyse
|
|
|
|
|
if(pointEnJeu==0) return "Optionnel";
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// autre chose que null, none ou vide (analyse très simple) toutes les autres fonctions sont ignorées
|
|
|
|
|
if(Sujet!=null) if(Sujet.contains("†")) {
|
|
|
|
|
if(A==null) return "Erreur : -" + pointString;
|
|
|
|
|
if(A.equals("none")) return "Erreur : -" + pointString;
|
|
|
|
|
if(A.isEmpty()) return "Erreur : -" + pointString;
|
|
|
|
|
IncrementPointClass(pointEnJeu);
|
|
|
|
|
return "Correct : +" + pointString;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// fonction ET CONTIENT plusieurs textes - quelque chose mais pas vide -
|
|
|
|
|
if(Sujet!=null) if(Sujet.contains("×") && !Sujet.contains("¢") && !Sujet.contains("→") && !Sujet.contains("#") && !Sujet.contains("¦") && !Sujet.contains("↕") && !Sujet.contains("↑") ) {
|
|
|
|
|
if(A==null) return "Erreur : -" + pointString;
|
|
|
|
|
if(A.equals("none")) return "Erreur : -" + pointString;
|
|
|
|
|
if(A.isEmpty()) return "Erreur : -" + pointString;
|
|
|
|
|
|
|
|
|
|
if(TraitementETContient(A,Sujet).equals("Correct : ")) {
|
|
|
|
|
IncrementPointClass(pointEnJeu);
|
|
|
|
|
return "Correct : +" + pointString;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return "Erreur : -" + pointString;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// fonction OU puis ET CONTIENT plusieurs textes - quelque chose mais pas vide -
|
|
|
|
|
if(Sujet!=null) if(Sujet.contains("×") && Sujet.contains("¦") && !Sujet.contains("¦(") && !Sujet.contains("¢") && !Sujet.contains("→") && !Sujet.contains("#") && !Sujet.contains("↕") && !Sujet.contains("↑") ) {
|
|
|
|
|
if(A==null) return "Erreur : -" + pointString;
|
|
|
|
|
if(A.equals("none")) return "Erreur : -" + pointString;
|
|
|
|
|
if(A.isEmpty()) return "Erreur : -" + pointString;
|
|
|
|
|
|
|
|
|
|
if(TraitementOUETcontient(A,Sujet).equals("Correct : ")) {
|
|
|
|
|
IncrementPointClass(pointEnJeu);
|
|
|
|
|
return "Correct : +" + pointString;
|
|
|
|
|
}
|
|
|
|
|
return "Erreur : -" + pointString;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// nettoyage du texte avant de l'analyser et similitude
|
|
|
|
|
// si ne contient pas d'autres fonctions cette fonction ne peut pas être combinée
|
|
|
|
|
if(Sujet!=null) if(Sujet.contains("¢") && !Sujet.contains("→") && !Sujet.contains("#") && !Sujet.contains("¦") && !Sujet.contains("↕") && !Sujet.contains("↑") ) {
|
|
|
|
|
if(A==null) A="null";
|
|
|
|
|
if(similitudeString(A, Sujet,commandes.tolerance_text)) {
|
|
|
|
|
IncrementPointClass(pointEnJeu);
|
|
|
|
|
return "Correct : +" + pointString;
|
|
|
|
|
}
|
|
|
|
|
return "Erreur : -" + pointString;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
//intervalle valeur simple pas de bordure, pas de couleur, et pas d'autres fonctions
|
|
|
|
|
if(Sujet.contains("→") && A!=null && !Sujet.contains("#") && !Sujet.contains("¦") && !Sujet.contains("↕") && !Sujet.contains("↑") && !Sujet.contains("¢")) {
|
|
|
|
|
if (TraitementIntervalle(A,Sujet).equals("Correct : ")) {
|
|
|
|
|
IncrementPointClass(pointEnJeu);
|
|
|
|
|
return "Correct : +" + pointString;
|
|
|
|
|
}else {
|
|
|
|
|
return "Erreur : -" + pointString;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// bordure simple avec ou sans intervalles ou autres fonctions
|
|
|
|
|
if(Sujet.contains("#") && Sujet.contains("pt") && Sujet.contains(" ") && !Sujet.contains("¦") && !Sujet.contains("↕") && !Sujet.contains("↑") && !Sujet.contains("¢") ) {
|
|
|
|
|
if(TraitementBordure2(Sujet,A).equals("Correct : ")) {
|
|
|
|
|
IncrementPointClass(pointEnJeu);
|
|
|
|
|
return "Correct : +" + pointString;
|
|
|
|
|
}else {
|
|
|
|
|
return "Erreur : -" + pointString;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// couleur simple pas de bordure ou pas d'autres fonctions
|
|
|
|
|
if(Sujet.contains("#") && !Sujet.contains("pt") && Sujet.contains(" ") && !Sujet.contains("¦") && !Sujet.contains("↕") && !Sujet.contains("↑") && !Sujet.contains("¢") ) {
|
|
|
|
|
if(TraitementCouleur(Sujet,A).equals("Correct : ")) {
|
|
|
|
|
IncrementPointClass(pointEnJeu);
|
|
|
|
|
return "Correct : +" + pointString;
|
|
|
|
|
}else {
|
|
|
|
|
return "Erreur : -" + pointString;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
//Exact avec OU sans d'autres fonctions OU
|
|
|
|
|
if(Sujet.contains("¦") && !Sujet.contains("↕") && !Sujet.contains("↑") && !Sujet.contains("¢")) {
|
|
|
|
|
if(TraitementOUExact(A,Sujet).equals("Correct : ")) {
|
|
|
|
|
IncrementPointClass(pointEnJeu);
|
|
|
|
|
return "Correct : +" + pointString;
|
|
|
|
|
}else {
|
|
|
|
|
return "Erreur : -" + pointString;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
//OU Exact mais sans les espaces et sans d'autres fonctions OU
|
|
|
|
|
if(Sujet.contains("≡") && !Sujet.contains("¦") && !Sujet.contains("↕") && !Sujet.contains("↑") && !Sujet.contains("¢")) {
|
|
|
|
|
if(TraitementOUExactSansEspace(A,Sujet).equals("Correct : ")) {
|
|
|
|
|
IncrementPointClass(pointEnJeu);
|
|
|
|
|
return "Correct : +" + pointString;
|
|
|
|
|
}else {
|
|
|
|
|
return "Erreur : -" + pointString;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
//Opérateur OU avec nettoyage du texte
|
|
|
|
|
if(Sujet.contains("↕") && !Sujet.contains("¦") && !Sujet.contains("↑") && !Sujet.contains("¢")) {
|
|
|
|
|
if(TraitementOU(A,Sujet).equals("Correct : ")) {
|
|
|
|
|
IncrementPointClass(pointEnJeu);
|
|
|
|
|
return "Correct : +" + pointString;
|
|
|
|
|
}else {
|
|
|
|
|
return "Erreur : -" + pointString;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
//Opérateur ou avec nettoyage des caractères spéciaux et des chiffres
|
|
|
|
|
if(Sujet.contains("↑") && !Sujet.contains("¦") && !Sujet.contains("↕") && !Sujet.contains("¢")) {
|
|
|
|
|
if(TraitementOUSupprimeChiffreEtsansCase(A,Sujet).equals("Correct : ")) {
|
|
|
|
|
IncrementPointClass(pointEnJeu);
|
|
|
|
|
return "Correct : +" + pointString;
|
|
|
|
|
}else {
|
|
|
|
|
return "Erreur : -" + pointString;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// ne contient aucune fonction
|
|
|
|
|
if(!Sujet.contains("≡") && !Sujet.contains("¦") && !Sujet.contains("↕") && !Sujet.contains("↑") && !Sujet.contains("¢") && !Sujet.contains("†") && !Sujet.contains("→")) {
|
|
|
|
|
if(A!=null)if(A.equals("auto")) A=null;
|
|
|
|
|
if(Sujet!=null)if(Sujet.equals("auto")) Sujet=null;
|
|
|
|
|
|
|
|
|
|
if(A!=null) if(A.equals("0cm")) A=null;
|
|
|
|
|
if(Sujet!=null) if(Sujet.equals("0cm")) Sujet=null;
|
|
|
|
|
|
|
|
|
|
if(A!=null) if(A.equals("none")) A=null;
|
|
|
|
|
if(Sujet!=null) if(Sujet.equals("none")) Sujet=null;
|
|
|
|
|
|
|
|
|
|
if(A!=null) if(A.isEmpty()) A=null;
|
|
|
|
|
if(Sujet!=null) if(Sujet.isEmpty()) Sujet=null;
|
|
|
|
|
|
|
|
|
|
if(A!=null) if(A.equals("0")) A=null;
|
|
|
|
|
if(Sujet!=null) if(Sujet.equals("0")) Sujet=null;
|
|
|
|
|
|
|
|
|
|
if(A!=null) if(A.equals("null")) A=null;
|
|
|
|
|
if(Sujet!=null) if(Sujet.equals("null")) Sujet=null;
|
|
|
|
|
|
|
|
|
|
if(A!=null) if(A.equals("false")) A=null;
|
|
|
|
|
if(Sujet!=null) if(Sujet.equals("false")) Sujet=null;
|
|
|
|
|
|
|
|
|
|
if(A!=null) if(Sujet==null) if(!pointString.isEmpty()) { return "Erreur : -" + pointString;}
|
|
|
|
|
if(A!=null) if(Sujet==null) if(pointString.isEmpty()) {return "Erreur";}
|
|
|
|
|
if(A==null) if(Sujet==null) if(!pointString.isEmpty()){IncrementPointClass(pointEnJeu); return "Correct : +" + pointString;}
|
|
|
|
|
if(A==null) if(Sujet==null) if(pointString.isEmpty()) {IncrementPointClass(pointEnJeu); return "Correct";}
|
|
|
|
|
|
|
|
|
|
if(A==null) if(Sujet!=null) if(!pointString.isEmpty()) return "Erreur : -" + pointString;
|
|
|
|
|
if(A==null) if(Sujet!=null) if(pointString.isEmpty()) return "Erreur";
|
|
|
|
|
|
|
|
|
|
if(!pointString.isEmpty()) {
|
|
|
|
|
if(A.equals(Sujet)){
|
|
|
|
|
IncrementPointClass(pointEnJeu);
|
|
|
|
|
return "Correct : +" + pointString;}
|
|
|
|
|
else {
|
|
|
|
|
return "Erreur : -" + pointString;
|
|
|
|
|
}
|
|
|
|
|
}else {
|
|
|
|
|
if(A.equals(Sujet)){
|
|
|
|
|
IncrementPointClass(pointEnJeu);
|
|
|
|
|
return "Correct";}
|
|
|
|
|
else {
|
|
|
|
|
return "Erreur";
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}else {
|
|
|
|
|
return "Erreur combinaison avec † ¢ → ¦ ↕ ↑ ×";
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Traitement des points du paramètre
|
|
|
|
|
* @param B
|
|
|
|
|
* @return
|
|
|
|
|
*/
|
|
|
|
|
public static String TraitePoint(String B) {
|
|
|
|
|
int point = 0;
|
|
|
|
|
pointEnJeu=0;
|
|
|
|
|
String pointString ="";
|
|
|
|
|
String C =B.substring(B.indexOf("‽")+1,B.length());
|
|
|
|
|
if(B!=null) if(B.contains("‽")) if(B.length()>1) if(!C.isEmpty()) {
|
|
|
|
|
try {
|
|
|
|
|
point = Integer.valueOf(B.substring(B.indexOf("‽")+1,B.length()));
|
|
|
|
|
}catch (Exception e) {
|
2022-04-29 19:17:58 +02:00
|
|
|
|
System.out.println("ERREUR sur la ventillation des points : " +B);
|
2022-04-25 13:25:20 +02:00
|
|
|
|
e.getMessage();
|
|
|
|
|
}
|
|
|
|
|
}else {
|
|
|
|
|
point=0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if(point==0) {
|
|
|
|
|
pointString="";
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if(point>0) {
|
|
|
|
|
pointString = Integer.valueOf(point) + " pt";
|
|
|
|
|
IncrementPointTotal(point);
|
|
|
|
|
pointEnJeu= point;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return pointString;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Traitement des intervalles
|
|
|
|
|
* @return
|
|
|
|
|
*/
|
|
|
|
|
private static String TraitementIntervalle(String A, String B) {
|
|
|
|
|
if(A.isEmpty()) return "Erreur : ";
|
|
|
|
|
|
|
|
|
|
String Text[] = B.split("→");
|
|
|
|
|
|
|
|
|
|
// rechercher un digite une ou plusieur fois en fin.
|
|
|
|
|
Pattern p = Pattern.compile("[^0-9\\.]");
|
|
|
|
|
|
|
|
|
|
// remplacement de toutes les occurrences par ""
|
|
|
|
|
Text[0]= p.matcher(Text[0]).replaceAll("");
|
|
|
|
|
Text[1] = p.matcher(Text[1]).replaceAll("");
|
|
|
|
|
A = p.matcher(A).replaceAll("");
|
|
|
|
|
|
|
|
|
|
double b0 = Double.valueOf(Text[0]);
|
|
|
|
|
double b1 = Double.valueOf(Text[1]);
|
|
|
|
|
|
|
|
|
|
if(A.isEmpty()) return "Erreur : ";
|
|
|
|
|
double v = Double.valueOf(A);
|
|
|
|
|
|
|
|
|
|
if(v<=b1 && v>=b0 ) return "Correct : ";
|
|
|
|
|
|
|
|
|
|
return "Erreur : ";
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2022-11-26 21:45:46 +01:00
|
|
|
|
/**
|
|
|
|
|
* Retourne la valeur minimale d'un intervale.
|
|
|
|
|
* @param Intervale
|
|
|
|
|
* @return
|
|
|
|
|
*/
|
2022-11-26 16:05:52 +01:00
|
|
|
|
public static double TraitementIntervaleRetourneValeurMinimale(String Intervale) {
|
|
|
|
|
String Text[] = Intervale.split("→");
|
|
|
|
|
|
|
|
|
|
// rechercher un digite une ou plusieur fois en fin.
|
|
|
|
|
Pattern p = Pattern.compile("[^0-9\\.]");
|
|
|
|
|
|
|
|
|
|
// remplacement de toutes les occurrences par ""
|
|
|
|
|
Text[0]= p.matcher(Text[0]).replaceAll("");
|
|
|
|
|
|
|
|
|
|
double b0 = Double.valueOf(Text[0]);
|
2022-11-26 21:45:46 +01:00
|
|
|
|
|
2022-11-26 16:05:52 +01:00
|
|
|
|
return b0;
|
|
|
|
|
}
|
|
|
|
|
|
2022-11-26 21:45:46 +01:00
|
|
|
|
/**
|
|
|
|
|
* Retourne la valeur maximale d'un intervalle.
|
|
|
|
|
* @param Intervale
|
|
|
|
|
* @return
|
|
|
|
|
*/
|
2022-11-26 16:05:52 +01:00
|
|
|
|
public static double TraitementIntervaleRetourneValeurMaximale(String Intervale) {
|
|
|
|
|
String Text[] = Intervale.split("→");
|
|
|
|
|
|
|
|
|
|
// rechercher un digite une ou plusieur fois en fin.
|
|
|
|
|
Pattern p = Pattern.compile("[^0-9\\.]");
|
|
|
|
|
|
|
|
|
|
// remplacement de toutes les occurrences par ""
|
|
|
|
|
Text[0]= p.matcher(Text[0]).replaceAll("");
|
|
|
|
|
Text[1] = p.matcher(Text[1]).replaceAll("");
|
2022-11-26 21:45:46 +01:00
|
|
|
|
|
2022-11-26 16:05:52 +01:00
|
|
|
|
double b1 = Double.valueOf(Text[1]);
|
|
|
|
|
|
|
|
|
|
return b1;
|
|
|
|
|
}
|
|
|
|
|
|
2022-04-25 13:25:20 +02:00
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Traitement des bordures
|
|
|
|
|
* Avec ou sans intervalle sur l'épaisseur des traits
|
|
|
|
|
* Avec 3 styles de tarits solid, dashed, double
|
|
|
|
|
* Avec traitement de la couleur
|
|
|
|
|
* @param Sujet
|
|
|
|
|
* @param B
|
|
|
|
|
* @return
|
|
|
|
|
*/
|
|
|
|
|
private static String TraitementBordure2(String Sujet, String B) {
|
|
|
|
|
if(Sujet.isEmpty()) return "Erreur : ";
|
|
|
|
|
if(B==null) return "Erreur : ";
|
|
|
|
|
|
|
|
|
|
String TextB[] = B.split(" ");
|
|
|
|
|
String TextA[] = Sujet.split(" ");
|
|
|
|
|
|
|
|
|
|
if(TextB.length!=3 || TextA.length!=3) return "Erreur : ";
|
|
|
|
|
|
|
|
|
|
boolean taille = false;
|
|
|
|
|
boolean type = false;
|
|
|
|
|
boolean couleur =false;
|
|
|
|
|
|
|
|
|
|
// traitement de la taille (epaisseur du trait)
|
|
|
|
|
if(TextA[0].contains("→")) {
|
|
|
|
|
if(TraitementIntervalle(TextB[0], TextA[0]).equals("Correct : ")) taille = true;
|
|
|
|
|
}else {
|
|
|
|
|
double tailleA = Double.valueOf(TextA[0].replace("pt",""));
|
|
|
|
|
double tailleB = Double.valueOf(TextB[0].replace("pt",""));
|
|
|
|
|
double IT = 0.02;
|
|
|
|
|
if((tailleA<tailleB+IT) && (tailleA>tailleB-IT))taille = true;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// traitement du type de trait
|
|
|
|
|
String typeA = TextA[1];
|
|
|
|
|
String typeB = TextB[1];
|
|
|
|
|
|
|
|
|
|
//trait pointillé
|
|
|
|
|
if(typeA.equals("dash-dot")) typeA="dashed";
|
|
|
|
|
if(typeB.equals("dash-dot")) typeB="dashed";
|
|
|
|
|
if(typeA.equals("dotted")) typeA="dashed";
|
|
|
|
|
if(typeB.equals("dotted")) typeB="dashed";
|
|
|
|
|
if(typeA.equals("fine-dashed")) typeA="dashed";
|
|
|
|
|
if(typeB.equals("fine-dashed")) typeB="dashed";
|
|
|
|
|
if(typeB.equals("dash-dot-dot")) typeB="dashed";
|
|
|
|
|
if(typeA.equals("dash-dot-dot")) typeA="dashed";
|
|
|
|
|
|
|
|
|
|
if(typeA.equals("double-thin")) typeA="double";
|
|
|
|
|
if(typeB.equals("double-thin")) typeB="double";
|
|
|
|
|
if(typeA.equals("outset")) typeA="double";
|
|
|
|
|
if(typeB.equals("outset")) typeB="double";
|
|
|
|
|
if(typeA.equals("inset")) typeA="double";
|
|
|
|
|
if(typeB.equals("inset")) typeB="double";
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
if(typeA.equals("groove")) typeA="solid";
|
|
|
|
|
if(typeB.equals("groove")) typeB="solid";
|
|
|
|
|
if(typeA.equals("ridge")) typeA="solid";
|
|
|
|
|
if(typeB.equals("ridge")) typeB="solid";
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
if(typeA.equals(typeB)) type=true;
|
|
|
|
|
|
|
|
|
|
// traitement de la couleur du trait
|
|
|
|
|
String couleurA = TextA[2].replace("#", "");
|
|
|
|
|
String couleurB = TextB[2].replace("#", "");
|
|
|
|
|
|
|
|
|
|
if(couleurA.equals(couleurB)) couleur = true;
|
|
|
|
|
|
|
|
|
|
if(!couleur) {
|
|
|
|
|
if(TraitementCouleur(couleurA, couleurB).equals("Correct : ")) {
|
|
|
|
|
couleur =true;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if(taille && type && couleur) return "Correct : ";
|
|
|
|
|
|
|
|
|
|
return "Erreur : ";
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Traitement de la couleur par comparaison
|
|
|
|
|
* La tolérance sur les 3 couleurs primaires RVB est de plus ou moins 30 par défaut.
|
|
|
|
|
* @param A
|
|
|
|
|
* @param B
|
|
|
|
|
* @return
|
|
|
|
|
*/
|
|
|
|
|
private static String TraitementCouleur(String Sujet, String B) {
|
|
|
|
|
if(B==null) return "Erreur : ";
|
|
|
|
|
if(B.isEmpty()) return "Erreur : ";
|
|
|
|
|
|
|
|
|
|
// traitement de la couleur du trait
|
|
|
|
|
String couleurS = Sujet.replace("#", "");
|
|
|
|
|
String couleurB = B.replace("#", "");
|
|
|
|
|
|
|
|
|
|
if(couleurS.equals(couleurB)) return "Correct : ";
|
|
|
|
|
|
|
|
|
|
if(couleurS.length()==6 && couleurB.length()==6) {
|
|
|
|
|
int Sred = Integer.parseInt(couleurS.substring(0, 2),16);
|
|
|
|
|
int Sgreen = Integer.parseInt(couleurS.substring(2, 4),16);
|
|
|
|
|
int Sblue = Integer.parseInt(couleurS.substring(4, 6),16);
|
|
|
|
|
|
|
|
|
|
int Bred = Integer.parseInt(couleurB.substring(0, 2),16);
|
|
|
|
|
int Bgreen = Integer.parseInt(couleurB.substring(2, 4),16);
|
|
|
|
|
int Bblue = Integer.parseInt(couleurB.substring(4, 6),16);
|
|
|
|
|
|
|
|
|
|
// couleur dominante avec 10 niveau
|
|
|
|
|
// if(Sred>Sgreen+10 && Sred>Sblue+10 && Bred>Bgreen+10 && Bred>=Bblue+10) return "Correct : ";//couleur=true; //Couleur dominante rouge
|
|
|
|
|
// if(Sgreen>Sred+10 && Sgreen>Sblue+10 && Bgreen>Bred+10 && Bgreen>Bblue+10) return "Correct : "; //couleur = true; //Couleur dominante vert
|
|
|
|
|
// if(Sblue>Sred+10 && Sblue>Sgreen+10 && Bblue>Bred+10 && Bblue>Bgreen+10) return "Correct : "; //couleur = true; //Couleur dominante bleu
|
|
|
|
|
// if(Sblue==Sred && Sblue==Sgreen && Bblue==Bred && Bblue==Bgreen) return "Correct : "; //couleur = true; //Couleur gris (tous les gris)
|
|
|
|
|
if(procheCouleur(Sred,Bred,Sgreen,Bgreen,Sblue,Bblue)) return "Correct : "; //couleur = true; //Couleur gris (tous les gris)
|
|
|
|
|
}
|
|
|
|
|
//if(couleur) return "Correct : ";
|
|
|
|
|
|
|
|
|
|
return "Erreur : ";
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Couleur proche avec une tolérance par défaut de 20 nuances dans l'espace colorométrique RVB.
|
|
|
|
|
* @param R1 Rouge Sujet
|
|
|
|
|
* @param R2 Rouge Student
|
|
|
|
|
* @param V1 Vert Sujet
|
|
|
|
|
* @param V2 Vert Student
|
|
|
|
|
* @param B1 Bleu Sujet
|
|
|
|
|
* @param B2 Bleu Student
|
|
|
|
|
* @return
|
|
|
|
|
*/
|
|
|
|
|
private static Boolean procheCouleur(int R1, int R2, int V1, int V2, int B1, int B2) {
|
|
|
|
|
int ecartR = Math.abs(R1-R2);
|
|
|
|
|
int ecartV = Math.abs(V1-V2);
|
|
|
|
|
int ecartB = Math.abs(B1-B2);
|
|
|
|
|
if((ecartR <=commandes.tolerance_rouge)&&(ecartV <=commandes.tolerance_vert)&&(ecartB <=commandes.tolerance_bleu) )return true;
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Traitement des conditions OU avec nettoyage du texte
|
|
|
|
|
* Comparaison egale, contient , similitude
|
|
|
|
|
* @param A
|
|
|
|
|
* @param B
|
|
|
|
|
* @return
|
|
|
|
|
*/
|
|
|
|
|
private static String TraitementOU(String A, String B) {
|
|
|
|
|
if(A==null) A="none";
|
|
|
|
|
if(A.isEmpty()) A="none";
|
|
|
|
|
|
|
|
|
|
A = NetTexte(A);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
String TextB[] = B.split("↕");
|
|
|
|
|
for(int i=0;i<TextB.length;i++) {
|
|
|
|
|
TextB[i] = NetTexte(TextB[i]);
|
|
|
|
|
if(A.equals(TextB[i])) return "Correct : ";
|
|
|
|
|
if(A.contains(TextB[i])) return "Correct : ";
|
|
|
|
|
if(similitudeString(A, TextB[i],commandes.tolerance_text)) return "Correct : ";
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return "Erreur : ";
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Traitement Exact
|
|
|
|
|
* @param A
|
|
|
|
|
* @param B
|
|
|
|
|
* @return
|
|
|
|
|
*/
|
|
|
|
|
private static String TraitementOUExact(String A, String B) {
|
|
|
|
|
if(A==null && !B.contains("null")) return "Erreur : ";
|
|
|
|
|
if(A==null && B.contains("null")) return "Correct : ";
|
|
|
|
|
|
|
|
|
|
String TextB[] = B.split("¦");
|
|
|
|
|
for(int i=0;i<TextB.length;i++) {
|
|
|
|
|
if(!TextB[i].contains("→")) {
|
|
|
|
|
if(A.equals(TextB[i])) return "Correct : ";
|
|
|
|
|
}else {
|
|
|
|
|
if (TraitementIntervalle(A,TextB[i]).equals("Correct : ")) return "Correct : ";
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return "Erreur : ";
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
*
|
|
|
|
|
* @param A
|
|
|
|
|
* @param Sujet
|
|
|
|
|
* @return
|
|
|
|
|
*/
|
|
|
|
|
private static String TraitementOUExactSansEspace(String A, String Sujet) {
|
|
|
|
|
if(A==null && !Sujet.contains("null")) return "Erreur : ";
|
|
|
|
|
if(A==null && Sujet.contains("null")) return "Correct : ";
|
|
|
|
|
|
|
|
|
|
A = A.replace(" ", "");
|
|
|
|
|
String TextB[] = Sujet.split("≡");
|
|
|
|
|
for(int i=0;i<TextB.length;i++) {
|
|
|
|
|
if(!TextB[i].contains("→")) {
|
|
|
|
|
if(A.equals(TextB[i].replace(" ", ""))) return "Correct : ";
|
|
|
|
|
}else {
|
|
|
|
|
if (TraitementIntervalle(A,TextB[i].replace(" ", "")).equals("Correct : ")) return "Correct : ";
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return "Erreur : ";
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Fonction ET contient le texte du node Sujet
|
|
|
|
|
* @param A
|
|
|
|
|
* @param Sujet
|
|
|
|
|
* @return
|
|
|
|
|
*/
|
|
|
|
|
private static String TraitementETContient(String A, String Sujet) {
|
|
|
|
|
String TextB[] = Sujet.split("×");
|
|
|
|
|
boolean Correct = false;
|
|
|
|
|
for(int i=0;i<TextB.length;i++) {
|
|
|
|
|
if(!TextB[i].isEmpty()) {
|
|
|
|
|
if(A.trim().contains(TextB[i].trim())) {
|
|
|
|
|
Correct = true;
|
|
|
|
|
}else {
|
|
|
|
|
return "Erreur : ";
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
if(Correct) return "Correct : ";
|
|
|
|
|
return "Erreur : ";
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Fonction OU contenant des ET contient le texte du node Sujet
|
|
|
|
|
* @param A
|
|
|
|
|
* @param Sujet
|
|
|
|
|
* @return
|
|
|
|
|
*/
|
|
|
|
|
private static String TraitementOUETcontient(String A, String Sujet) {
|
|
|
|
|
String TextB[] = Sujet.split("¦");
|
|
|
|
|
|
|
|
|
|
for(int i=0;i<TextB.length;i++) {
|
|
|
|
|
if(TextB[i].contains("×")) {
|
|
|
|
|
if(TraitementETContient( A, TextB[i]).equals("Correct : ")) return "Correct : ";
|
|
|
|
|
}else {
|
|
|
|
|
if(A.trim().contains(TextB[i].trim())) return "Correct : ";
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return "Erreur : ";
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Traitement des condition OU en supprimant les chiffres
|
|
|
|
|
* @param A
|
|
|
|
|
* @param B
|
|
|
|
|
* @return
|
|
|
|
|
*/
|
|
|
|
|
private static String TraitementOUSupprimeChiffreEtsansCase(String A, String B) {
|
|
|
|
|
if(A==null) A="none";
|
|
|
|
|
if(A.isEmpty()) A="none";
|
|
|
|
|
|
|
|
|
|
// rechercher un digite une ou plusieur fois en fin.
|
|
|
|
|
Pattern p = Pattern.compile("[0-9]");
|
|
|
|
|
// création du moteur associé à la regex sur la chaîne A
|
|
|
|
|
Matcher m = p.matcher(A);
|
|
|
|
|
// remplacement de toutes les occurrences par ""
|
|
|
|
|
A= m.replaceAll("");
|
|
|
|
|
A=A.toLowerCase();
|
|
|
|
|
|
|
|
|
|
m = p.matcher(B);
|
|
|
|
|
B = m.replaceAll("");
|
|
|
|
|
B= B.toLowerCase();
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
A = NetTexte(A);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
String TextB[] = B.split("↑");
|
|
|
|
|
for(int i=0;i<TextB.length;i++) {
|
|
|
|
|
TextB[i] = NetTexte(TextB[i]);
|
|
|
|
|
if(A.equals(TextB[i].toLowerCase())) return "Correct : ";
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return "Erreur : ";
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Sans les point
|
|
|
|
|
* @param B
|
|
|
|
|
* @return
|
|
|
|
|
*/
|
|
|
|
|
public static String withoutPoint(String B) {
|
|
|
|
|
if(B!=null) if(B.contains("‽")) {
|
|
|
|
|
B=B.substring(0, B.indexOf("‽"));
|
|
|
|
|
}
|
|
|
|
|
return B;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
public static String withoutCode(String B) {
|
|
|
|
|
B=B.replace("¢", "");
|
|
|
|
|
return B;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public static String withoutCodeAndPoint(String B) {
|
|
|
|
|
if(B!=null) {
|
|
|
|
|
if(B.contains("‽")) B=B.substring(0, B.indexOf("‽"));
|
|
|
|
|
if(!B.isEmpty()) B=B.replace("¢", "");
|
|
|
|
|
}
|
|
|
|
|
return B;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Uniquement suppression des codes ‽, ↑, ↕, ≡, ¢<br>
|
|
|
|
|
* pour effectuer la recherche d'un node par son contenu.
|
|
|
|
|
* @param B un string
|
|
|
|
|
* @return B un string
|
|
|
|
|
*/
|
|
|
|
|
public static String withoutCodeAndPointPourRechercheContenuExact(String B) {
|
|
|
|
|
if(B!=null) {
|
2022-04-29 19:17:58 +02:00
|
|
|
|
if(B.contains("‽")) B=B.replaceAll("‽[0-9]{0,}", ""); //B=B.substring(0, B.indexOf("‽"));
|
2022-05-07 20:43:07 +02:00
|
|
|
|
if(!B.isEmpty()) if(B.contains("↑")) B=B.replace("↑", "");
|
|
|
|
|
if(!B.isEmpty()) if(B.contains("↕")) B=B.replace("↕", "");
|
|
|
|
|
if(!B.isEmpty()) if(B.contains("≡")) B=B.replace("≡", "");
|
|
|
|
|
if(!B.isEmpty()) if(B.contains("¢")) B=B.replace("¢", "");
|
|
|
|
|
if(!B.isEmpty()) B=B.replaceAll("‽[0-9]{1,}", "");
|
2022-04-25 13:25:20 +02:00
|
|
|
|
}
|
|
|
|
|
return B;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Supprime les caracatères spéciaux, la pontuaction, tous les espaces, et les chiffres<br>
|
|
|
|
|
* Bascule le texte en minuscule.<br>
|
|
|
|
|
* @param A Le texte qui doit être nettoyé.
|
|
|
|
|
* @return Le texte nettoyé.
|
|
|
|
|
*/
|
2022-04-29 19:17:58 +02:00
|
|
|
|
public static String NetTexte(String A) {
|
2022-04-25 13:25:20 +02:00
|
|
|
|
if (A!=null) {
|
|
|
|
|
A=A.toLowerCase().trim();
|
|
|
|
|
A = A.replace("'", "");
|
|
|
|
|
A = A.replace(""", "");
|
|
|
|
|
|
2022-04-28 12:44:52 +02:00
|
|
|
|
Pattern pt = Pattern.compile("[^a-z0-9]"); // avec les chiffres "[^a-zA-Z0-9]"
|
2022-04-25 13:25:20 +02:00
|
|
|
|
Matcher match= pt.matcher(A);
|
|
|
|
|
while(match.find()){
|
|
|
|
|
String s= match.group();
|
|
|
|
|
A=A.replaceAll("\\"+s, "");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
A=A.replaceAll("[0-9]", "");
|
|
|
|
|
A=A.replace(" ", "");
|
|
|
|
|
|
|
|
|
|
A=A.toLowerCase();
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
return A;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Netoyage les chiffres placés à la fin du texte.<br>
|
|
|
|
|
* Cette méthode est utilisée pour supprimer les numéros de page dans les index (table de matières par exemple).<br>
|
|
|
|
|
* @param A Le texte.
|
|
|
|
|
* @return Le texte A sans chiffre à la fin du texte.
|
|
|
|
|
*/
|
|
|
|
|
public static String NetChiffreALaFin(String A) {
|
|
|
|
|
A=A.replaceAll("{1,}[0-9]", "");
|
|
|
|
|
return A;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Retourne la chaîne sans le numéro à la fin
|
|
|
|
|
* @param A
|
|
|
|
|
* @return
|
|
|
|
|
*/
|
|
|
|
|
public static String RemoveLastNumber(String A) {
|
|
|
|
|
Pattern p = Pattern.compile("[0-9]+$");
|
|
|
|
|
Matcher m = p.matcher(A);
|
|
|
|
|
A= m.replaceAll("");
|
|
|
|
|
return A;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
*
|
|
|
|
|
* @param A
|
|
|
|
|
* @param B
|
|
|
|
|
* @return
|
|
|
|
|
*/
|
|
|
|
|
public static ArrayList<node> AjouteDansALesNodesB(ArrayList<node> A,ArrayList<node> B){
|
|
|
|
|
for(int i=0; i<B.size();i++) {
|
|
|
|
|
A.add(B.get(i));
|
|
|
|
|
}
|
|
|
|
|
return A;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Initialisation des points
|
|
|
|
|
*/
|
|
|
|
|
public static void initiliseLesPoints() {
|
|
|
|
|
pointsClass=0;
|
|
|
|
|
pointEnJeu=0;
|
|
|
|
|
pointTotal=0;
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Compare deux chaînes de caractères avec un seuil de similitude (79% par défaut).<br>
|
|
|
|
|
* Lorsque les deux chaînes de caractères partages 79% des caractères comparés par groupe de 2 ou 3 ou 4. Alors retourne TRUE.<br>
|
|
|
|
|
* Lorsque les deux chaînes de caractères partages moins de 79% des caractères comparés par groupe de 2 ou 3 ou 4. Alors retourne FALSE.<br>
|
|
|
|
|
* Les Chaînes de caractères doivent avoir au moins 6 caractères, après néttoyage du texte avec la méthode NetTexte().<br>
|
|
|
|
|
* Sinon le seuil de tolérance est de 99.99%.<br>
|
|
|
|
|
* <ul>
|
|
|
|
|
* <li>Lorsque la longueur de la chaîne de caractères est inférieure à 50 caractères alors compare par groupe de 2 caractères.</li>
|
|
|
|
|
* <li>Lorsque la longueur de la chaîne de caractères est entre à 50 et 200 caractères alors compare par groupe de 3 caractères.</li>
|
|
|
|
|
* <li>Lorsque la longueur de la chaîne de caractères est supérieure à 200 caractères alors compare par groupe de 4 caractères.</li>
|
|
|
|
|
* </ul>
|
|
|
|
|
* <br>
|
|
|
|
|
* @param A Chaîne de caracatères de l'étudiant.
|
|
|
|
|
* @param Modele Chaîne de caractères du sujet.
|
|
|
|
|
* @param tolerance_text Le seuil de tolérance pour la comparaison (valeur comprise entre 0 et 1).
|
|
|
|
|
* @return TRUE ou FALSE en fonction de la comparaison et du seuil de tolérance.
|
|
|
|
|
*/
|
|
|
|
|
private static boolean similitudeString(String A, String Modele, Double tolerance_text) {
|
|
|
|
|
if(tolerance_text==null) tolerance_text = 0.79 ;
|
|
|
|
|
|
|
|
|
|
Modele = NetTexte(Modele);
|
|
|
|
|
A = NetTexte(A);
|
|
|
|
|
|
|
|
|
|
double Sim = StringSimilarity.similarity(A, Modele);
|
|
|
|
|
|
|
|
|
|
if(Sim<tolerance_text) return false;
|
|
|
|
|
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Remplace les _20_ par un espace
|
|
|
|
|
* Remplace les _26_ par un &
|
|
|
|
|
* @param A
|
|
|
|
|
* @return
|
|
|
|
|
*/
|
2022-06-16 16:45:48 +02:00
|
|
|
|
public static String remplaceCaracteresCodageAttribut(String A) {
|
2022-04-25 13:25:20 +02:00
|
|
|
|
if(A!=null) {
|
|
|
|
|
A = A.replace("_20_", " ");
|
|
|
|
|
A = A.replace("_26_", "&");
|
|
|
|
|
}
|
|
|
|
|
return A;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
public static int getPointsClass() {
|
|
|
|
|
return pointsClass;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
public static int getPointTotal() {
|
|
|
|
|
return pointTotal;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
public static int getPointEnJeu() {
|
|
|
|
|
return pointEnJeu;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public static double getProportionCorrect() {
|
|
|
|
|
return (double) pointsClass/pointTotal;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public static void setPointsClass(int ptsClass) {
|
|
|
|
|
pointsClass = ptsClass;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
public static void setPointTotal(int ptTotal) {
|
|
|
|
|
pointTotal = ptTotal;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
public static void setPointEnJeu(int ptEnJeu) {
|
|
|
|
|
pointEnJeu = ptEnJeu;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public static void IncrementPointTotal(Integer pt) {
|
2022-11-27 20:45:41 +01:00
|
|
|
|
pointEnJeu = pt;
|
2022-04-25 13:25:20 +02:00
|
|
|
|
pointTotal=pointTotal+ pt;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public static void decrementPointEnJeuDuTotal() {
|
|
|
|
|
pointTotal=pointTotal-pointEnJeu;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private static void IncrementPointClass(Integer pt) {
|
|
|
|
|
pointsClass=pointsClass+ pt;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|