JavaDoc et Gradation des axes Dones

UML/classes.puml

@@ -3,7 +3,6 @@
 namespace ecoparasite {
 
     class Application {
-        + {static} main
     }
 
     namespace ecoparasite.input {
@@ -120,109 +119,34 @@ namespace ecoparasite {
 
     namespace ecoparasite.completion {
         class Completion {
-            + {static} completeColumnsMoyenne()
+            + {static} completeColumnsMoyenne
-            + {static} completeColumnsLinear()
+            + {static} completeColumnsLinear
         }
     }
 
     namespace ecoparasite.nettoyage {
         class Nettoyage {
-            + {static} nettoieColumns()
+            + {static} nettoieColumnsMoyenne
+            + {static} nettoieColumnsLinear
         }
     }
 
-    namespace ecoparasite.representation {
+    namespace ecoparasite.unknown {
-        class ValeursXY {
+
-            - double x
+        note top of ecoparasite.unknown : Ce paquet est temporaire pour des classes / interfaces qui devront avoir plus de déclinaisons.
-            - double y
+
-            + {static} HashSet<ValeursXY> convertToXY()
+        class DataCleaner {
-        }
+            + DataCleaner()
+            + String toString()
         }
 
-    namespace ecoparasite.svg {
+        interface DataCompletion {
-        class SVGFactory {
+            + void exception()
-            + {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/Application.java

@@ -6,48 +6,86 @@ 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.util.ArrayList;
+import java.io.File;
-import java.util.HashMap;
+import java.util.*;
-import java.util.HashSet;
 import java.util.function.BiConsumer;
 import java.util.function.Function;
 
 public class Application {
 
-    public static void main(String[] args) throws InputFileException, RawDataOverflow {
+    static final String[] VALID_FILES = {"Campagne/mackerel.97442.csv", "Campagne/merlu2018_75164.csv","Combinés/ParasitesPeru2021.csv"};
 
-        RawData rawMackerel = InputFactory.readData("test2.csv", ",");
+    public static void validFileName(File dir, HashSet<String> listeName){
 
-        HashSet<Poisson> mackerelSet = MackerelSerra.parse(rawMackerel);
+        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);
 
-        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 );
@@ -63,8 +101,122 @@ public class Application {
         // Sauvegarde pour plus tard.
         double[] ABCoef = Completion.getLinearCoef(mackerelSet, getLength, getInfes);
 
-        ArrayList<Element> SVGElements = axesInstance.buildAll( "Length (mm)", "Taux d'infestation", mackerelXY, ABCoef[0], ABCoef[1] );
+        ArrayList<Element> SVGElements = axesInstance.buildAll( "Length", "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,15 +139,6 @@ 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,18 +14,6 @@ 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,10 +181,7 @@ 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,20 +3,11 @@ 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;
@@ -35,15 +26,6 @@ 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){
@@ -54,4 +36,11 @@ public class ValeursXY {
         return xy;
     }
 
+    /*
+    public static ValeursXY getMinX( HashSet<ValeursXY> list ){
+
+    }
+
+     */
+
 }

src/ecoparasite/svg/Coordonnees.java

@@ -1,8 +1,5 @@
 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,7 +1,4 @@
 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,10 +7,6 @@ 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;
@@ -26,14 +22,6 @@ 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 ){
@@ -68,10 +56,6 @@ 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 );
@@ -83,15 +67,6 @@ 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<>();
@@ -105,15 +80,8 @@ 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;
@@ -130,32 +98,25 @@ public class SVGBuilder {
         Coordonnees right = getResizer().resize( maxPointsX, beginAxeY );
 
         // Axes
-        elements.add( new Line( bottom, top, ElementsFactory.COLOR_WHITE, 2 ) );
+        elements.add( new Line( bottom, top, ElementsFactory.COLOR_BLACK, 2 ) );
-        elements.add( new Line( left, right, ElementsFactory.COLOR_WHITE, 2 ) );
+        elements.add( new Line( left, right, ElementsFactory.COLOR_BLACK, 2 ) );
 
         // Labels.
         elements.add( new Text(
            new Coordonnees( right.getX() + OFFSET_TEXT_AXISX_X, right.getY() + OFFSET_TEXT_AXISX_Y ),
-           XLabel, ElementsFactory.COLOR_WHITE, ElementsFactory.AXES_TEXT_SIZE
+           XLabel, ElementsFactory.COLOR_BLACK, 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_WHITE, ElementsFactory.AXES_TEXT_SIZE
+                YLabel, ElementsFactory.COLOR_BLACK, 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;
@@ -169,12 +130,12 @@ public class SVGBuilder {
             elements.add(new Line(
                     coords,
                     new Coordonnees( coords.getX(), coords.getY() + OFFSET_TICK ),
-                    ElementsFactory.COLOR_WHITE, 1
+                    ElementsFactory.COLOR_BLACK, 1
             ));
             elements.add(new Text(
                new Coordonnees( coords.getX() + OFFSET_TEXT_X, coords.getY() + OFFSET_TEXT_Y ),
                 X.toString(),
-                ElementsFactory.COLOR_WHITE,
+                ElementsFactory.COLOR_BLACK,
                 SIZE_TICK_TEXT
             ));
         }
@@ -182,12 +143,6 @@ 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;
@@ -203,12 +158,12 @@ public class SVGBuilder {
             elements.add(new Line(
                     new Coordonnees(coords.getX() + OFFSET_TICK, coords.getY() ),
                     coords,
-                    ElementsFactory.COLOR_WHITE, 1
+                    ElementsFactory.COLOR_BLACK, 1
             ));
             elements.add(new Text(
                     new Coordonnees( coords.getX() + OFFSET_TEXT_X, coords.getY() + OFFSET_TEXT_Y ),
                     Y.toString(),
-                    ElementsFactory.COLOR_WHITE,
+                    ElementsFactory.COLOR_BLACK,
                     SIZE_TICK_TEXT
             ));
         }
@@ -216,11 +171,6 @@ 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<>();
@@ -232,12 +182,6 @@ 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<>();
 
@@ -251,18 +195,10 @@ 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,9 +2,7 @@ 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;
@@ -61,7 +59,7 @@ public class SVGFactory {
      */
     public static String createSVGCode(ArrayList<Element> mesElements){
 
-        String code = "<svg height=\"" + ElementsFactory.SVG_SIZE + "\" width=\"" + ElementsFactory.SVG_SIZE + "\" >";
+        String code = "<svg height=\"800\" width=\"800\" >";
 
         for (Element e : mesElements){
 

src/ecoparasite/svg/SVGResizing.java

@@ -3,25 +3,13 @@ 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,
@@ -54,12 +42,6 @@ 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,20 +4,11 @@ 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;
@@ -46,10 +37,6 @@ 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,18 +2,10 @@ 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;
     }
@@ -32,7 +24,7 @@ abstract public class Element {
 
     /**
      * Méthode abstraite qui va permettre de transformer notre élément en SVG.
-     * @return La String SVG
+     * @return La String SVF
      */
     abstract public String toSVG();
 

src/ecoparasite/svg/elements/ElementsFactory.java

@@ -5,30 +5,13 @@ 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,22 +4,12 @@ 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;
@@ -66,10 +56,6 @@ 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,22 +4,12 @@ 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;
@@ -58,10 +48,6 @@ public class Text extends Element {
         this.size = size;
     }
 
-    /**
-     * Génère la string SVG.
-     * @return
-     */
     @Override
     public String toSVG() {
         StringBuilder svg = new StringBuilder();