UML/classes.puml

@@ -3,6 +3,7 @@
 namespace ecoparasite {
 
     class Application {
+        + {static} main
     }
 
     namespace ecoparasite.input {
@@ -119,34 +120,109 @@ namespace ecoparasite {
 
     namespace ecoparasite.completion {
         class Completion {
-            + {static} completeColumnsMoyenne
-            + {static} completeColumnsLinear
+            + {static} completeColumnsMoyenne()
+            + {static} completeColumnsLinear()
         }
     }
 
     namespace ecoparasite.nettoyage {
         class Nettoyage {
-            + {static} nettoieColumnsMoyenne
-            + {static} nettoieColumnsLinear
+            + {static} nettoieColumns()
         }
     }
 
-    namespace ecoparasite.unknown {
-
-        note top of ecoparasite.unknown : Ce paquet est temporaire pour des classes / interfaces qui devront avoir plus de déclinaisons.
-
-        class DataCleaner {
-            + DataCleaner()
-            + String toString()
+    namespace ecoparasite.representation {
+        class ValeursXY {
+            - double x
+            - double y
+            + {static} HashSet<ValeursXY> convertToXY()
+        }
     }
 
-        interface DataCompletion {
-            + void exception()
+    namespace ecoparasite.svg {
+        class SVGFactory {
+            + {static} createSVG()
+            + {static} createSVGCode()
+            + {static} createFile()
         }
+
+        class Coordonnees {
+            - double x
+            - double y
+        }
+
+        class SVGResizing {
+            - double minX
+            - double maxX
+            - double minY
+            - double maxY
+            + resize()
+        }
+
+        class SVGBuilder {
+            - ArrayList<Double> pointsX
+            - ArrayList<Double> pointsY
+            - double minPointsX
+            - double minPointsY
+            - double maxPointsX
+            - double maxPointsY
+            + SVGBuilder()
+            + getResizer()
+            + buildAll()
+            + buildAxes()
+            + buildXTicks()
+            + buildYTicks()
+            + buildPoints()
+            + buildRegression()
+            - getBeginAxeX()
+            - getBeginAxeY()
+            + {static} calcPointsAxes()
+            + {static} niceStep()
+            + {static} roundMin()
+            + {static} roundMax()
+        }
+
+        exception IncorrectAxesPointsException {
+        }
+
+        SVGBuilder o--> SVGResizing : - resizer
+
+    }
+
+    namespace ecoparasite.svg.elements {
+
+        class ElementsFactory {
+            + {static} SVGAxes()
+        }
+
+        abstract class Element {
+            + {abstract} toSVG()
+        }
+
+        Element o--> ecoparasite.svg.Coordonnees : # coordonnees
+
+        class Circle extends Element {
+            - int rayon
+            - String color
+        }
+
+        class Line extends Element {
+            - int lineWidth
+            - String color
+        }
+
+        class Text extends Element {
+            - String text
+            - String color
+            - int size
+        }
+
+        Line o--> ecoparasite.svg.Coordonnees : # coordonneesB
     }
 
 }
 Exception <|-- InputFileException
 Exception <|-- RawDataOverflow
+Exception <|-- IncorrectAxesPointsException
 
 @enduml

src/ecoparasite/completion/Completion.java

@@ -139,6 +139,15 @@ public class Completion {
         return meanY - valueA * meanX;
     }
 
+    /**
+     * Permet de retourner les coefficients de la regression linéaire.
+     * @param list La liste de données de type T.
+     * @param getX Le Getter des valeurs X.
+     * @param getY Le Getter des valeurs Y.
+     * @return Les coefficients a et b, [0] = a, [1] = b
+     * @param <T> Le type de données cobaye.
+     * @param <V> Le type de valeurs de retour numérique.
+     */
     public static <T,V extends Number> double[] getLinearCoef( HashSet<T> list, Function<T,V> getX,  Function<T,V> getY ){
 
         double meanX = calculateMean(list, getX);

src/ecoparasite/nettoyage/Nettoyage.java

@@ -14,6 +14,18 @@ import java.util.function.Function;
  */
 public class Nettoyage {
 
+    /**
+     * Permet de remplacer les valeurs abérrantes d'un paramètre d'un HashSet par null.
+     * Exemple d'utilisation : T = Poisson, V = Double, getValue = Poisson::getInfestation, setValue = Poisson::setInfestation.
+     *
+     * @param list La liste de données cobaye.
+     * @param getValue La fonction (Getter) qui permet d'obtenir la valeur que l'on veut vérifier
+     * @param setValue La fonction (Setter) qui permet de remplacer la valeur si null.
+     * @param allowNegative Savoir si une valeur négative est forcément aberrant.
+     * @return Le HashSet avec les valeurs remplacés.
+     * @param <T> Le type de données cobaye. Exemple : Poisson, Population
+     * @param <V> Le type de la donnée à vérifier, doit être un Wrapper Number. Exemple : Double.
+     */
     public static <T,V extends Number> HashSet<T> nettoieColumns(HashSet<T> list, Function<T,V> getValue, BiConsumer<T,V> setValue, boolean allowNegative ){
 
         ArrayList<Double> array = new ArrayList<>();

src/ecoparasite/population/PopulationArgs.java

@@ -181,7 +181,10 @@ public class PopulationArgs {
 
     public void setZone(String zone) { this.zone = zone; }
 
-
+    /**
+     * Avoir sous forme de string les données de nos arguments de population.
+     * @return
+     */
     @Override
     public String toString(){
         return String.format( "Année: %d, N: %d, Length: %f, Width: %f, Prevalence: %f, IC: %f, Intensity: %f, Abondance: %f, Zone: %s",

src/ecoparasite/representation/ValeursXY.java

@@ -3,11 +3,20 @@ package ecoparasite.representation;
 import java.util.HashSet;
 import java.util.function.Function;
 
+/**
+ * Représente un tuple de Valeurs X/Y pour nos données.
+ * Ce type de données est utilisé lors de la conversion entre nos données et la partie SVG.
+ */
 public class ValeursXY {
 
     private double x;
     private double y;
 
+    /**
+     * Constructeur
+     * @param x Notre valeur correspondant à l'axe X.
+     * @param y Notre valeur correspondant à l'axe Y.
+     */
     public ValeursXY(double x, double y){
         this.x = x;
         this.y = y;
@@ -26,6 +35,15 @@ public class ValeursXY {
         this.y = y;
     }
 
+    /**
+     * Permet de convertir un type de données en valeursXY.
+     * @param list Notre liste de données de type T.
+     * @param getX Notre getter pour notre valeur symbolisant X.
+     * @param getY Notre getter pour notre valeur symbolisant Y.
+     * @return Un HashSet de valeursXY.
+     * @param <T> Le type de données qui vont être converties.
+     * @param <V> Le type de données retournées comme un nombre.
+     */
     public static <T,V extends Number> HashSet<ValeursXY> convertToXY(HashSet<T> list, Function<T,V> getX, Function<T,V> getY){
         HashSet<ValeursXY> xy = new HashSet<ValeursXY>();
         for(T item : list){
@@ -36,11 +54,4 @@ public class ValeursXY {
         return xy;
     }
 
-    /*
-    public static ValeursXY getMinX( HashSet<ValeursXY> list ){
-
-    }
-
-     */
-
 }

src/ecoparasite/svg/Coordonnees.java

@@ -1,5 +1,8 @@
 package ecoparasite.svg;
 
+/**
+ * Classe qui permet de stocker les coordonnées utilisées pour le positionnement sur le fichier SVG.
+ */
 public class Coordonnees {
 
     private double x;

src/ecoparasite/svg/IncorrectAxesPointsException.java

@@ -1,4 +1,7 @@
 package ecoparasite.svg;
 
+/**
+ * Exception déclenchée lorsque le format des Axes est incorrect par rapport à ce que la fonction attend.
+ */
 public class IncorrectAxesPointsException extends Exception{
 }

src/ecoparasite/svg/SVGBuilder.java

@@ -7,6 +7,10 @@ import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.HashSet;
 
+/**
+ * Classe qui permet de construire les éléments présents sur le SVG.
+ * Axes, Points, Regression, Ticks.
+ */
 public class SVGBuilder {
 
     final int SIZE_TICK_TEXT = ElementsFactory.AXES_TEXT_SIZE - 3;
@@ -22,6 +26,14 @@ public class SVGBuilder {
     private Double maxPointsX;
     private Double maxPointsY;
 
+    /**
+     * Constructeur.
+     * Initialise les différentes variables tirées de axesPoints.
+     * @param axesPoints Paramètre tiré de la fonction calcPointsAxes.
+     * @throws IncorrectAxesPointsException Si le format de axesPoints est incorrect.
+     *
+     * @see SVGBuilder::calcPointsAxes
+     */
     public SVGBuilder(HashMap<String, ArrayList<Double>> axesPoints ) throws IncorrectAxesPointsException {
 
         if( axesPoints.get("AxeX") == null ||  axesPoints.get("AxeY") == null || axesPoints.get("OffsetX") == null || axesPoints.get("OffsetY") == null ){
@@ -56,6 +68,10 @@ public class SVGBuilder {
         return offsetY;
     }
 
+    /**
+     * Permet d'obtenir un resizer ou bien le crée s'il n'existe pas déjà.
+     * @return
+     */
     public SVGResizing getResizer() {
         if( this.resizer == null ){
             this.resizer = new SVGResizing( this.minPointsX, this.minPointsY, this.maxPointsX, this.maxPointsY );
@@ -67,6 +83,15 @@ public class SVGBuilder {
         this.resizer = resizer;
     }
 
+    /**
+     * Permet de tout construire d'un seul coup.
+     * @param XLabel Le nom de l'axe X.
+     * @param YLabel Le nom de l'axe Y.
+     * @param points Les points pour le nuage de points.
+     * @param A Le coefficient A de la regression
+     * @param B Le coefficient B de la regression
+     * @return Une liste d'éléments pour la génération du SVG.
+     */
     public ArrayList<Element> buildAll(String XLabel, String YLabel, HashSet<ValeursXY> points, double A, double B){
 
         ArrayList<Element> elements = new ArrayList<>();
@@ -80,8 +105,15 @@ public class SVGBuilder {
         return elements;
     }
 
+    /**
+     * Permet de construire les axes au format SVG.
+     * @param XLabel Le nom de l'axe X.
+     * @param YLabel Le nom de l'axe Y.
+     * @return La liste d'éléments SVG pour les axes.
+     */
     public ArrayList<Element> buildAxes(String XLabel, String YLabel){
 
+        // Offsets/Configuration.
         final int OFFSET_TEXT_AXISX_X = -20;
         final int OFFSET_TEXT_AXISX_Y = -10;
         final int OFFSET_TEXT_AXISY_X = +5;
@@ -115,8 +147,15 @@ public class SVGBuilder {
 
     }
 
+    /**
+     * Permet de construire les batons de l'axe X.
+     * Utilise this.pointsX
+     *
+     * @return La liste d'éléments des points X.
+     */
     public ArrayList<Element> buildXTicks(){
 
+        // Offsets/Configuration.
         final int OFFSET_TICK = -5;
         final int OFFSET_TEXT_X = -10;
         final int OFFSET_TEXT_Y = +15;
@@ -143,6 +182,12 @@ public class SVGBuilder {
         return elements;
     }
 
+    /**
+     * Permet de construire les batons de l'axe Y.
+     * Utilise this.pointsY
+     *
+     * @return La liste d'éléments des points Y.
+     */
     public ArrayList<Element> buildYTicks(){
 
         final int OFFSET_TICK = +5;
@@ -171,6 +216,11 @@ public class SVGBuilder {
         return elements;
     }
 
+    /**
+     * Construire le nuage de points sur le SVG.
+     * @param points La liste des points.
+     * @return La liste des éléments pour le nuage de points SVG.
+     */
     public ArrayList<Element> buildPoints( HashSet<ValeursXY> points ){
 
         ArrayList<Element> elements = new ArrayList<>();
@@ -182,6 +232,12 @@ public class SVGBuilder {
         return elements;
     }
 
+    /**
+     * Construire la droite de regression linéaire.
+     * @param A Coefficient a
+     * @param B Coefficient B
+     * @return La liste des éléments pour la droite.
+     */
     public ArrayList<Element> buildRegression( double A, double B ){
         ArrayList<Element> elements = new ArrayList<>();
 
@@ -195,10 +251,18 @@ public class SVGBuilder {
         return elements;
     }
 
+    /**
+     * Permet de savoir à quel point l'axe X doit débuter.
+     * @return Le double de début de l'axe X.
+     */
     private double getBeginAxeX(){
         return ( minPointsX > 0 ) ? minPointsX : ( maxPointsX < 0 ? maxPointsX : 0 );
     }
 
+    /**
+     * Permet de savoir à quel point l'axe Y doit débuter.
+     * @return Le double du début de l'axe Y.
+     */
     private double getBeginAxeY(){
         return ( minPointsY > 0 ) ? minPointsY : ( maxPointsY < 0 ? maxPointsY : 0 );
     }

src/ecoparasite/svg/SVGFactory.java

@@ -2,7 +2,9 @@ package ecoparasite.svg;
 
 import ecoparasite.representation.ValeursXY;
 import ecoparasite.svg.elements.Element;
+import ecoparasite.svg.elements.ElementsFactory;
 
+import javax.lang.model.util.ElementScanner14;
 import java.io.FileWriter;
 import java.io.IOException;
 import java.util.ArrayList;
@@ -59,7 +61,7 @@ public class SVGFactory {
      */
     public static String createSVGCode(ArrayList<Element> mesElements){
 
-        String code = "<svg height=\"800\" width=\"800\" >";
+        String code = "<svg height=\"" + ElementsFactory.SVG_SIZE + "\" width=\"" + ElementsFactory.SVG_SIZE + "\" >";
 
         for (Element e : mesElements){
 

src/ecoparasite/svg/SVGResizing.java

@@ -3,13 +3,25 @@ package ecoparasite.svg;
 import ecoparasite.representation.ValeursXY;
 import ecoparasite.svg.elements.ElementsFactory;
 
+/**
+ * Classe qui permet de convertir des doubles en dimension SVG.
+ */
 public class SVGResizing {
 
+
     private double minX;
     private double maxX;
     private double minY;
     private double maxY;
 
+    /**
+     * Constructeur.
+     * Définit les minimum et maximum X et Y.
+     * @param minXGrad
+     * @param minYGrad
+     * @param maxXGrad
+     * @param maxYGrad
+     */
     public SVGResizing(
         double minXGrad,
         double minYGrad,
@@ -42,6 +54,12 @@ public class SVGResizing {
         return this.resize( vxy.getX(), vxy.getY() );
     }
 
+    /**
+     * Permet de redimensionner quelconque valeur X Y (Provenant de ValeursXY par exemple) en Coordonnées SVG.
+     * @param X
+     * @param Y
+     * @return La coordonnée SVG équivalente.
+     */
     public Coordonnees resize( double X, double Y ){
         double surface = ElementsFactory.SVG_SIZE - 2 * ElementsFactory.SVG_OFFSET;
 

src/ecoparasite/svg/elements/Circle.java

@@ -4,11 +4,20 @@ import ecoparasite.svg.Coordonnees;
 
 import java.util.Locale;
 
+/**
+ * Element Cercle SVG.
+ */
 public class Circle extends Element {
 
     private int rayon;
     private String color;
 
+    /**
+     * Constructeur.
+     * @param coordonnees
+     * @param rayon
+     * @param color - Couleur provenant de ElementsFactory.
+     */
     public Circle(Coordonnees coordonnees, int rayon, String color) {
         super(coordonnees);
         this.rayon = rayon;
@@ -37,6 +46,10 @@ public class Circle extends Element {
         this.color = color;
     }
 
+    /**
+     * Crée la string SVG.
+     * @return La string SVG.
+     */
     @Override
     public String toSVG() {
         StringBuilder svg = new StringBuilder();

src/ecoparasite/svg/elements/Element.java

@@ -2,10 +2,18 @@ package ecoparasite.svg.elements;
 
 import ecoparasite.svg.Coordonnees;
 
+/**
+ * Classe abstraite qui permet de définir des éléments SVG.
+ */
 abstract public class Element {
 
     protected Coordonnees coordonnees;
 
+    /**
+     * Constructeur par défaut.
+     * Inscrit juste les coordonnées.
+     * @param coordonnees Les coordonnées.
+     */
     public Element(Coordonnees coordonnees) {
         this.coordonnees = coordonnees;
     }
@@ -24,7 +32,7 @@ abstract public class Element {
 
     /**
      * Méthode abstraite qui va permettre de transformer notre élément en SVG.
-     * @return La String SVF
+     * @return La String SVG
      */
     abstract public String toSVG();
 

src/ecoparasite/svg/elements/ElementsFactory.java

@@ -5,13 +5,29 @@ import ecoparasite.svg.Coordonnees;
 import java.util.ArrayList;
 import java.util.HashSet;
 
+/**
+ * Contient divers éléments utiles pour les fichiers SVG.
+ */
 public class ElementsFactory {
 
+    /**
+     * Taille du fichier SVG.
+     * SVG_SIZE * SVG_SIZE
+     */
     final public static int SVG_SIZE = 800;
+
+    /**
+     * Le décalage de cadre du fichier SVG.
+     */
     final public static int SVG_OFFSET = 50;
 
+    /**
+     * La taille du texte pour les axes.
+     */
     final public static int AXES_TEXT_SIZE = 10;
 
+    // Définition de couleurs.
+
     final public static String COLOR_WHITE = "white";
     final public static String COLOR_RED = "red";
     final public static String COLOR_BLUE = "blue";

src/ecoparasite/svg/elements/Line.java

@@ -4,12 +4,22 @@ import ecoparasite.svg.Coordonnees;
 
 import java.util.Locale;
 
+/**
+ * Permet de construire une droite/ligne en SVG.
+ */
 public class Line extends Element {
 
     private Coordonnees coordonneesB;
     private String color;
     private int lineWidth;
 
+    /**
+     * Constructeur
+     * @param coordonneesA Coordonnées de départ
+     * @param coordonneesB Coordonnées d'arrivé.
+     * @param color Couleur provenant de ElementsFactory
+     * @param lineWidth Epaisseur de la ligne.
+     */
     public Line(Coordonnees coordonneesA, Coordonnees coordonneesB, String color, int lineWidth) {
         super(coordonneesA);
         this.coordonneesB = coordonneesB;
@@ -56,6 +66,10 @@ public class Line extends Element {
         this.lineWidth = lineWidth;
     }
 
+    /**
+     * Génère la string SVG de l'élément.
+     * @return
+     */
     @Override
     public String toSVG() {
         StringBuilder svg = new StringBuilder();

src/ecoparasite/svg/elements/Text.java

@@ -4,12 +4,22 @@ import ecoparasite.svg.Coordonnees;
 
 import java.util.Locale;
 
+/**
+ * Élement qui permet de générer un texte sur le SVG.
+ */
 public class Text extends Element {
 
     private String text;
     private String color;
     private int size;
 
+    /**
+     * Constructeur
+     * @param coordonnees Les coordonnées du texte
+     * @param text
+     * @param color Provenant de ElementsFactory
+     * @param size La taille du texte
+     */
     public Text(Coordonnees coordonnees, String text, String color,  int size) {
         super(coordonnees);
         this.text = text;
@@ -48,6 +58,10 @@ public class Text extends Element {
         this.size = size;
     }
 
+    /**
+     * Génère la string SVG.
+     * @return
+     */
     @Override
     public String toSVG() {
         StringBuilder svg = new StringBuilder();