ecoparasite-data-analyse/src/ecoparasite/Application.java

package ecoparasite;

import ecoparasite.completion.Completion;
import ecoparasite.input.InputFactory;
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.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", "test2.csv"};

    public static void validFileName(File dir, HashSet<String> listeName){

        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);
        */

        System.out.println( "Liste des fichiers valides:" );
        for (String validFile : VALID_FILES) {
            System.out.print(validFile + " ");
        }
        System.out.println();

        while (!isValid) {
            System.out.println("Veuillez rentrez le nom du fichier :");
            name = sc.nextLine();

            for (int i = 0; i < VALID_FILES.length; 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 le 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, getInfes, setInfes, false );
        mackerelSet = Completion.completeColumnsLinear( mackerelSet, getLength, getInfes, setInfes );

        System.out.println( "Après le nettoyage et complétion");
        System.out.println( mackerelSet );

        HashSet<ValeursXY> mackerelXY = ValeursXY.convertToXY( mackerelSet, getLength, getInfes );
        HashMap<String, ArrayList<Double>> axes = SVGBuilder.calcPointAxes( mackerelXY );
        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(mackerelSet, getLength, getInfes);

        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( "Avant le nettoyage et complétion");
        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 );

        System.out.println( "Après le nettoyage et complétion");
        System.out.println( merluSet );

        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 (mm)", "Taux d'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;
        System.out.println( "Avant complétion et nettoyage de la masse" );
        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().getAbondance() : null;
        };

        popSet = Nettoyage.nettoieColumns(popSet, getLength, setLength, false);
        System.out.println("Après nettoyage de la masse");
        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("Après complétion de la masse");

        index = 1;
        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;
        }

        double[] ABCoef = Completion.getLinearCoef(popSet, getLength, getInfes);

        ArrayList<Element> elements = axesInstance.buildAll( "Taille en mm", "Abondance", popXY, ABCoef[0], ABCoef[1] );
        SVGFactory.createSVG(elements);
    }

    public static void test2Render(String name) throws InputFileException,RawDataOverflow{

        RawData rawMackerel = InputFactory.readData(name, ",");

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

        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(mackerelSet, getLength, getInfes);

        ArrayList<Element> SVGElements = axesInstance.buildAll( "Length (mm)", "Taux d'infestation", mackerelXY, ABCoef[0], ABCoef[1] );
        SVGFactory.createSVG( SVGElements );

    }

    public static void main(String[] args) {

        String nameFile = Application.validFile();

        try {
            if (nameFile.contains("mackerel")) {
                MackerelFile(nameFile);
            } else if (nameFile.contains("merlu")) {
                MerluFile(nameFile);
            } else if (nameFile.contains("Peru")) {
                PopPeru(nameFile);
            } else if (nameFile.contains("test2")) {
                test2Render(nameFile);
            }
        } catch ( InputFileException e ){
            System.out.println( e.getMessage() );
        } catch ( RawDataOverflow e ){
            System.out.println( e.getMessage() );
        }

    }
}