Tracé des axes

src/ecoparasite/svg/SVGAxes.java

@@ -0,0 +1,181 @@
+package ecoparasite.svg;
+
+import ecoparasite.svg.elements.Element;
+import ecoparasite.svg.elements.ElementsFactory;
+import ecoparasite.svg.elements.Line;
+import ecoparasite.svg.elements.Text;
+
+import java.lang.reflect.Array;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+
+public class SVGAxes {
+
+    final int SIZE_TICK_TEXT = ElementsFactory.AXES_TEXT_SIZE - 3;
+
+    private ArrayList<Double> pointsX;
+    private ArrayList<Double> pointsY;
+    private Double offsetX;
+    private Double offsetY;
+    private SVGResizing resizer;
+
+    private Double minPointsX;
+    private Double minPointsY;
+    private Double maxPointsX;
+    private Double maxPointsY;
+
+    public SVGAxes( HashMap<String, ArrayList<Double>> axesPoints ) throws IncorrectAxesPointsException {
+
+        if( axesPoints.get("AxeX") == null ||  axesPoints.get("AxeY") == null || axesPoints.get("OffsetX") == null || axesPoints.get("OffsetY") == null ){
+            throw new IncorrectAxesPointsException();
+        }
+
+        this.pointsX = axesPoints.get("AxeX");
+        this.pointsY = axesPoints.get("AxeY");
+        this.offsetX = axesPoints.get("OffsetX").getFirst();
+        this.offsetY = axesPoints.get("OffsetY").getFirst();
+
+        this.minPointsX = this.pointsX.getFirst();
+        this.minPointsY = this.pointsY.getFirst();
+        this.maxPointsX = this.pointsX.getLast();
+        this.maxPointsY = this.pointsY.getLast();
+
+    }
+
+    public ArrayList<Double> getPointsX() {
+        return pointsX;
+    }
+
+    public ArrayList<Double> getPointsY() {
+        return pointsY;
+    }
+
+    public Double getOffsetX() {
+        return offsetX;
+    }
+
+    public Double getOffsetY() {
+        return offsetY;
+    }
+
+    public SVGResizing getResizer() {
+        if( this.resizer == null ){
+            this.resizer = new SVGResizing( this.minPointsX, this.minPointsY, this.maxPointsX, this.maxPointsY );
+        }
+        return resizer;
+    }
+
+    public void setResizer(SVGResizing resizer) {
+        this.resizer = resizer;
+    }
+
+    public ArrayList<Element> buildAll(String XLabel, String YLabel){
+
+        ArrayList<Element> elements = new ArrayList<>();
+        elements.addAll(buildAxes(XLabel, YLabel));
+        elements.addAll(buildXTicks());
+        elements.addAll(buildYTicks());
+
+        return elements;
+    }
+
+    public ArrayList<Element> buildAxes(String XLabel, String YLabel){
+
+        final int OFFSET_TEXT_AXISX_X = -20;
+        final int OFFSET_TEXT_AXISX_Y = -10;
+        final int OFFSET_TEXT_AXISY_X = +5;
+        final int OFFSET_TEXT_AXISY_Y = +10;
+
+        ArrayList<Element> elements = new ArrayList<>();
+
+        double beginAxeX = getBeginAxeX();
+        double beginAxeY = getBeginAxeY();
+
+        Coordonnees bottom = getResizer().resize( beginAxeX, minPointsY );
+        Coordonnees top = getResizer().resize( beginAxeX, maxPointsY );
+        Coordonnees left = getResizer().resize( minPointsX, beginAxeY );
+        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 ) );
+
+        // 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
+        ) );
+        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
+        ));
+
+        return elements;
+
+    }
+
+    public ArrayList<Element> buildXTicks(){
+
+        final int OFFSET_TICK = -5;
+        final int OFFSET_TEXT_X = -10;
+        final int OFFSET_TEXT_Y = +15;
+
+        ArrayList<Element> elements = new ArrayList<>();
+
+        double beginAxeY = getBeginAxeY();
+        for( Double X : this.pointsX ){
+            Coordonnees coords = getResizer().resize( X, beginAxeY );
+
+            elements.add(new Line(
+                    coords,
+                    new Coordonnees( coords.getX(), coords.getY() + OFFSET_TICK ),
+                    ElementsFactory.COLOR_BLACK, 1
+            ));
+            elements.add(new Text(
+               new Coordonnees( coords.getX() + OFFSET_TEXT_X, coords.getY() + OFFSET_TEXT_Y ),
+                X.toString(),
+                ElementsFactory.COLOR_BLACK,
+                SIZE_TICK_TEXT
+            ));
+        }
+
+        return elements;
+    }
+
+    public ArrayList<Element> buildYTicks(){
+
+        final int OFFSET_TICK = +5;
+        final int OFFSET_TEXT_X = -35;
+        final int OFFSET_TEXT_Y = +5;
+
+        ArrayList<Element> elements = new ArrayList<>();
+
+        double beginAxeX = getBeginAxeX();
+        for( Double Y : this.pointsY ){
+            Coordonnees coords = getResizer().resize( beginAxeX, Y );
+
+            elements.add(new Line(
+                    new Coordonnees(coords.getX() + OFFSET_TICK, coords.getY() ),
+                    coords,
+                    ElementsFactory.COLOR_BLACK, 1
+            ));
+            elements.add(new Text(
+                    new Coordonnees( coords.getX() + OFFSET_TEXT_X, coords.getY() + OFFSET_TEXT_Y ),
+                    Y.toString(),
+                    ElementsFactory.COLOR_BLACK,
+                    SIZE_TICK_TEXT
+            ));
+        }
+
+        return elements;
+    }
+
+    private double getBeginAxeX(){
+        return ( minPointsX > 0 ) ? minPointsX : ( maxPointsX < 0 ? maxPointsX : 0 );
+    }
+
+    private double getBeginAxeY(){
+        return ( minPointsY > 0 ) ? minPointsY : ( maxPointsY < 0 ? maxPointsY : 0 );
+    }
+}