Merge remote-tracking branch 'origin/27.04.26-2' into 27.04.26-2

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 {
+    namespace ecoparasite.representation {
+        class ValeursXY {
+            - double x
+            - double y
+            + {static} HashSet<ValeursXY> convertToXY()
+        }
+    }
 
-        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.svg {
+        class SVGFactory {
+            + {static} createSVG()
+            + {static} createSVGCode()
+            + {static} createFile()
         }
 
-        interface DataCompletion {
-            + void exception()
+        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/Application.java

@@ -6,86 +6,48 @@ import ecoparasite.input.InputFileException;
 import ecoparasite.input.RawData;
 import ecoparasite.input.RawDataOverflow;
 import ecoparasite.nettoyage.Nettoyage;
-import ecoparasite.poisson.Mackerel;
 import ecoparasite.poisson.MackerelSerra;
-import ecoparasite.poisson.Merlu;
 import ecoparasite.poisson.Poisson;
-import ecoparasite.population.Population;
-import ecoparasite.population.PopulationArgInterval;
-import ecoparasite.population.PopulationParsing;
 import ecoparasite.representation.ValeursXY;
 import ecoparasite.svg.IncorrectAxesPointsException;
 import ecoparasite.svg.SVGBuilder;
 import ecoparasite.svg.SVGFactory;
 import ecoparasite.svg.elements.Element;
 
-import java.io.File;
-import java.util.*;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
 import java.util.function.BiConsumer;
 import java.util.function.Function;
 
 public class Application {
 
-    static final String[] VALID_FILES = {"Campagne/mackerel.97442.csv", "Campagne/merlu2018_75164.csv","Combinés/ParasitesPeru2021.csv"};
+    public static void main(String[] args) throws InputFileException, RawDataOverflow {
 
-    public static void validFileName(File dir, HashSet<String> listeName){
+        RawData rawMackerel = InputFactory.readData("test2.csv", ",");
 
-        File[] liste = dir.listFiles();
-
-        for (File item : liste) {
-            if (!item.isDirectory()){
-                listeName.add(item.getName());
-            } else {
-                validFileName(new File(dir.getName()+ "/" + item.getName()), listeName);
-            }
-        }
-
-    }
-
-    public static String validFile(){
-
-        Scanner sc = new Scanner(System.in);
-        String name = "";
-        boolean isValid = false;
-
-        /*
-        File dir = new File("data");
-
-        HashSet<String> listeName = new HashSet<>();
-
-        Application.validFileName(dir,listeName);
-        */
-
-        while (!isValid) {
-            System.out.println("Veuillez rentrez le nom du fichier :");
-            name = sc.nextLine();
-
-            for (int i = 0; i < 3; i++) {
-                if (name.contains(VALID_FILES[i])){
-                    isValid = true;
-                    break;
-                }
-            }
-        }
-
-        return name;
-    }
-
-    public static void MackerelFile(String name) throws InputFileException, RawDataOverflow {
-
-        RawData rawMackerel = InputFactory.readData(name);
-
-        HashSet<Poisson> mackerelSet = Mackerel.parse(rawMackerel);
+        HashSet<Poisson> mackerelSet = MackerelSerra.parse(rawMackerel);
 
+        System.out.println( "Avant nettoyage et complétion" );
         System.out.println( mackerelSet );
 
         Function<Poisson,Double> getLength = Poisson::getLength;
         Function<Poisson,Double> getInfes = Poisson::getInfestation;
         BiConsumer<Poisson,Double> setInfes = Poisson::setInfestation;
 
+        mackerelSet = Nettoyage.nettoieColumns( mackerelSet, Poisson::getLength, Poisson::setLength, false );
+        mackerelSet = Completion.completeColumnsMoyenne( mackerelSet, Poisson::getLength, Poisson::setLength );
+
+        System.out.println( "Après Nettoyage et complétion de la longueur du poisson." );
+        System.out.println( mackerelSet );
+
         mackerelSet = Nettoyage.nettoieColumns( mackerelSet, getInfes, setInfes, false );
         mackerelSet = Completion.completeColumnsLinear( mackerelSet, getLength, getInfes, setInfes );
 
+        System.out.println( "Après Nettoyage et complétion du taux d'infestation des poissons" );
+        System.out.println( mackerelSet );
+
+        // Conversion des valeurs.
         HashSet<ValeursXY> mackerelXY = ValeursXY.convertToXY( mackerelSet, getLength, getInfes );
         HashMap<String, ArrayList<Double>> axes = SVGBuilder.calcPointAxes( mackerelXY );
         System.out.println( axes );
@@ -101,122 +63,8 @@ public class Application {
         // Sauvegarde pour plus tard.
         double[] ABCoef = Completion.getLinearCoef(mackerelSet, getLength, getInfes);
 
-        ArrayList<Element> SVGElements = axesInstance.buildAll( "Length", "Infestation", mackerelXY, ABCoef[0], ABCoef[1] );
+        ArrayList<Element> SVGElements = axesInstance.buildAll( "Length (mm)", "Taux d'infestation", mackerelXY, ABCoef[0], ABCoef[1] );
         SVGFactory.createSVG( SVGElements );
-    }
-
-    public static void MerluFile(String name) throws InputFileException, RawDataOverflow {
-
-        RawData rawMerlu = InputFactory.readData(name);
-
-        HashSet<Poisson> merluSet = Merlu.parse(rawMerlu);
-
-        System.out.println( merluSet );
-
-        Function<Poisson,Double> getLength = Poisson::getLength;
-        Function<Poisson,Double> getInfes = Poisson::getInfestation;
-        BiConsumer<Poisson,Double> setInfes = Poisson::setInfestation;
-
-        merluSet = Nettoyage.nettoieColumns( merluSet, getInfes, setInfes, false );
-        merluSet = Completion.completeColumnsLinear( merluSet, getLength, getInfes, setInfes );
-
-        HashSet<ValeursXY> merluXY = ValeursXY.convertToXY( merluSet, getLength, getInfes );
-        HashMap<String, ArrayList<Double>> axes = SVGBuilder.calcPointAxes( merluXY );
-        System.out.println( axes );
-
-        SVGBuilder axesInstance;
-        try {
-            axesInstance = new SVGBuilder(axes);
-        } catch (IncorrectAxesPointsException e) {
-            System.out.println( "Mauvais format communiqué" );
-            return;
-        }
-
-        // Sauvegarde pour plus tard.
-        double[] ABCoef = Completion.getLinearCoef(merluSet, getLength, getInfes);
-
-        ArrayList<Element> SVGElements = axesInstance.buildAll( "Length", "Infestation", merluXY, ABCoef[0], ABCoef[1] );
-        SVGFactory.createSVG( SVGElements );
-    }
-
-    public static void PopPeru(String name) throws InputFileException,RawDataOverflow{
-
-        RawData popRaw; int index;
-        try {
-            popRaw = InputFactory.readData(name , "," );
-        } catch(InputFileException e) {
-            System.out.println(e.getMessage());
-            return;
-        }
-
-        HashSet<Population> popSet = PopulationParsing.parseParasitesPeru(popRaw);
-
-        index = 1;
-        for( Population p: popSet){
-            System.out.println(String.valueOf(index++) + p);
-        }
-
-        // Nettoyage de la taille.
-        Function<Population,Double> getLength = population -> {
-            return population.getTotal().getLength() != null ? population.getTotal().getLength().transformToDouble() : null;
-        };
-        BiConsumer<Population,Double> setLength = (population, aDouble) -> {
-            population.getTotal().setLength(aDouble != null ? new PopulationArgInterval(aDouble,aDouble) : null);
-        };
-
-        Function<Population,Double> getInfes = population -> {
-            return population.getTotal().getAbondance() != null ? population.getTotal().getPrevalence().transformToDouble() : null;
-        };
-
-        popSet = Nettoyage.nettoieColumns(popSet, getLength, setLength, false);
-        System.out.println("---");
-        index = 1;
-        for( Population p: popSet){
-            System.out.println(String.valueOf(index++) + p);
-        }
-
-        // Complétion de la masse.
-        popSet = Completion.completeColumnsMoyenne(popSet, getLength, setLength);
-        System.out.println("---");
-        for( Population p: popSet){
-            System.out.println(String.valueOf(index++) + p);
-        }
-
-        HashSet<ValeursXY> popXY = ValeursXY.convertToXY( popSet, getLength, getInfes );
-        HashMap<String, ArrayList<Double>> axes = SVGBuilder.calcPointAxes( popXY );
-        System.out.println( axes );
-
-        SVGBuilder axesInstance;
-        try {
-            axesInstance = new SVGBuilder(axes);
-        } catch (IncorrectAxesPointsException e) {
-            System.out.println( "Mauvais format communiqué" );
-            return;
-        }
-
-
-        ArrayList<Element> elements = new ArrayList<>();
-
-        elements.addAll(axesInstance.buildAxes("Taille en mm", "Abondance"));
-        elements.addAll(axesInstance.buildXTicks());
-        elements.addAll(axesInstance.buildYTicks());
-        elements.addAll(axesInstance.buildPoints(popXY));
-
-        SVGFactory.createSVG(elements);
-    }
-
-    public static void main(String[] args) throws InputFileException, RawDataOverflow {
-
-        String nameFile = Application.validFile();
-
-        if (nameFile.contains("mackerel")) {
-            MackerelFile(nameFile);
-        } else if (nameFile.contains("merlu")){
-            MerluFile(nameFile);
-        } else if (nameFile.contains("Peru")) {
-            PopPeru(nameFile);
-        }
-
 
     }
 }

src/ecoparasite/completion/Completion.java

@@ -139,10 +139,19 @@ 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);
-        double meanY =  calculateMean(list, getY);
+        double meanX = calculateMean(list, getX);
+        double meanY = calculateMean(list, getY);
 
         double a = calculateLinearA(list,getX,getY,meanX,meanY);
         double b = calculateLinearB(meanX,meanY,a);

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;
@@ -98,25 +130,32 @@ public class SVGBuilder {
         Coordonnees right = getResizer().resize( maxPointsX, beginAxeY );
 
         // Axes
-        elements.add( new Line( bottom, top, ElementsFactory.COLOR_BLACK, 2 ) );
-        elements.add( new Line( left, right, ElementsFactory.COLOR_BLACK, 2 ) );
+        elements.add( new Line( bottom, top, ElementsFactory.COLOR_WHITE, 2 ) );
+        elements.add( new Line( left, right, ElementsFactory.COLOR_WHITE, 2 ) );
 
         // Labels.
         elements.add( new Text(
            new Coordonnees( right.getX() + OFFSET_TEXT_AXISX_X, right.getY() + OFFSET_TEXT_AXISX_Y ),
-           XLabel, ElementsFactory.COLOR_BLACK, ElementsFactory.AXES_TEXT_SIZE
+           XLabel, ElementsFactory.COLOR_WHITE, ElementsFactory.AXES_TEXT_SIZE
         ) );
         elements.add( new Text(
                 new Coordonnees( top.getX() + OFFSET_TEXT_AXISY_X, top.getY() + OFFSET_TEXT_AXISY_Y ),
-                YLabel, ElementsFactory.COLOR_BLACK, ElementsFactory.AXES_TEXT_SIZE
+                YLabel, ElementsFactory.COLOR_WHITE, ElementsFactory.AXES_TEXT_SIZE
         ));
 
         return elements;
 
     }
 
+    /**
+     * 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;
@@ -130,12 +169,12 @@ public class SVGBuilder {
             elements.add(new Line(
                     coords,
                     new Coordonnees( coords.getX(), coords.getY() + OFFSET_TICK ),
-                    ElementsFactory.COLOR_BLACK, 1
+                    ElementsFactory.COLOR_WHITE, 1
             ));
             elements.add(new Text(
                new Coordonnees( coords.getX() + OFFSET_TEXT_X, coords.getY() + OFFSET_TEXT_Y ),
                 X.toString(),
-                ElementsFactory.COLOR_BLACK,
+                ElementsFactory.COLOR_WHITE,
                 SIZE_TICK_TEXT
             ));
         }
@@ -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;
@@ -158,12 +203,12 @@ public class SVGBuilder {
             elements.add(new Line(
                     new Coordonnees(coords.getX() + OFFSET_TICK, coords.getY() ),
                     coords,
-                    ElementsFactory.COLOR_BLACK, 1
+                    ElementsFactory.COLOR_WHITE, 1
             ));
             elements.add(new Text(
                     new Coordonnees( coords.getX() + OFFSET_TEXT_X, coords.getY() + OFFSET_TEXT_Y ),
                     Y.toString(),
-                    ElementsFactory.COLOR_BLACK,
+                    ElementsFactory.COLOR_WHITE,
                     SIZE_TICK_TEXT
             ));
         }
@@ -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,30 @@ 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";
     final public static String COLOR_BLACK = "black";

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();