Correction version finale

src/main/java/ByteGrayColor.java

 import javafx.scene.paint.Color;
 
-/**
- * Created by Arnaud Labourel on 02/10/2018.
- */
-
 public class ByteGrayColor implements GrayColor {
 
     private static final int MINIMUM_GRAY_LEVEL = 0;
     private static final int MAXIMUM_GRAY_LEVEL = 255;
     private static final int OPACITY = 1;
 
-    private final int grayLevel;
+    public static final ByteGrayColor WHITE = new ByteGrayColor(MAXIMUM_GRAY_LEVEL);
+    public static final ByteGrayColor BLACK = new ByteGrayColor(MINIMUM_GRAY_LEVEL);
 
+    private static final double MAXIMUM_LUMINOSITY = 1.;
+
+    private final int grayLevel;
 
     public ByteGrayColor(){
         this.grayLevel = MINIMUM_GRAY_LEVEL;
     }
 
     public ByteGrayColor(int grayLevel) {
-        // TODO : Corriger l'initialisation de la propriété grayLevel de l'instance.
-        this.grayLevel = 0;
+        this.grayLevel = grayLevel;
     }
 
     public ByteGrayColor(double luminosity) {
-        // TODO : Corriger l'initialisation de la propriété grayLevel de l'instance.
-        this.grayLevel = 0;
+        this.grayLevel = (int) (luminosity * MAXIMUM_GRAY_LEVEL);
     }
 
     @Override
     public double getLuminosity() {
-        // TODO : Retourner la luminosité de la couleur (entre 0 noir et 1 blanc)
-        return 0;
+        return grayLevel/(double) MAXIMUM_GRAY_LEVEL;
     }
 
     @Override
     public Color getColor(){
-        double component = grayLevel / (double) MAXIMUM_GRAY_LEVEL;
+        double component = getLuminosity();
         return new Color(component, component, component, OPACITY);
     }
 
-
     @Override
     public int compareTo(GrayColor o) {
-        // TODO : Retourner la différence de niveau de gris.
-        return 0;
+        return Double.compare(this.getLuminosity(), o.getLuminosity());
     }
 
     @Override
@@ -54,4 +49,12 @@ public class ByteGrayColor implements GrayColor {
         return this.compareTo(color) == 0;
     }
 
+    @Override
+    public GrayColor invert() {
+        return new ByteGrayColor(invertedLuminosity());
+    }
+
+    private double invertedLuminosity() {
+        return MAXIMUM_LUMINOSITY - getLuminosity();
+    }
 }
\ No newline at end of file

src/main/java/CompositeTransform.java

+/**
+ * Created by Arnaud Labourel on 04/10/2018.
+ */
+
+public class CompositeTransform implements Transform {
+    private final Transform[] transforms;
+
+    public CompositeTransform(Transform[] transforms) {
+        this.transforms = transforms;
+    }
+
+    @Override
+    public void applyTo(GrayImage image) {
+        for(Transform transform : transforms){
+            transform.applyTo(image);
+        }
+    }
+}

src/main/java/CrissCross.java

+/**
+ * Created by Arnaud Labourel on 04/10/2018.
+ */
+public class CrissCross implements Transform{
+
+    private final int size;
+
+    public CrissCross(int size){
+        this.size = size;
+    }
+
+    @Override
+    public void applyTo(GrayImage image) {
+        for(int x = 0; x < image.getWidth(); x++) {
+            for(int y = 0; y < image.getHeight(); y++) {
+                modifyPixel(image, x, y);
+            }
+        }
+    }
+
+    private void modifyPixel(GrayImage image, int x, int y) {
+        if(x % size == 0 || y % size ==0){
+            image.setPixel(ByteGrayColor.BLACK, x, y);
+        }
+    }
+}

src/main/java/DecreaseGrayLevels.java

+/**
+ * Created by Arnaud Labourel on 04/10/2018.
+ */
+public class DecreaseGrayLevels implements Transform {
+
+    private final int nbGrayLevels;
+
+    public DecreaseGrayLevels(int nbGrayLevels) {
+        this.nbGrayLevels = nbGrayLevels;
+    }
+
+    @Override
+    public void applyTo(GrayImage image) {
+        for(int x = 0; x < image.getWidth(); x++) {
+            for (int y = 0; y < image.getHeight(); y++) {
+                modifyPixel(image, x, y);
+            }
+        }
+    }
+
+    private void modifyPixel(GrayImage image, int x, int y) {
+        int numberOfIntervals = nbGrayLevels - 1;
+        double sizeOfIntervals = 1. / (double) numberOfIntervals;
+        double luminosity = image.getPixelGrayColor(x, y).getLuminosity();
+        double newLuminosity = Math.floor(luminosity * numberOfIntervals) * sizeOfIntervals;
+        image.setPixel(new ByteGrayColor(newLuminosity), x, y);
+    }
+}

src/main/java/Display.java

@@ -21,8 +21,10 @@ public class Display implements Initializable {
 
     this.image = MatrixGrayImage.createImageFromPGMFile("images/luminy.pgm");
 
-        // TODO : Ajouter les transformations d'image.
+    Transform transform = new CompositeTransform(new Transform[] {new DecreaseGrayLevels(8), new Outline(0.05), new Invert()});
 
+    transform.applyTo(image);
+    image.writeIntoPGMFormat("/Users/arnaudlabourel/luminy.pgm");
     render();
   }
 
@@ -49,3 +51,4 @@ public class Display implements Initializable {
   }
 
 }
+

src/main/java/GrayColor.java

@@ -4,7 +4,9 @@ import javafx.scene.paint.Color;
  * Created by Arnaud Labourel on 04/10/2018.
  * Interface correspondant à une couleur de gris.
  */
+
 public interface GrayColor extends Comparable<GrayColor> {
     double getLuminosity();
     Color getColor();
+    GrayColor invert();
 }

src/main/java/GrayImage.java

+
 /**
- * Created by Arnaud Labourel on 04/10/2018.
+ * Interface pour une image avec des nuances de gris.
  */
 
 public interface GrayImage extends Image {

src/main/java/Image.java

 import javafx.scene.paint.Color;
 
 /**
- * Created by Arnaud Labourel on 02/10/2018.
+ * Interface pour une image.
  */
 public interface Image {
     Color getPixelColor(int x, int y);

src/main/java/Invert.java

+/**
+ * Created by Arnaud Labourel on 04/10/2018.
+ */
+public class Invert implements Transform{
+    @Override
+    public void applyTo(GrayImage image) {
+        for(int x = 0; x < image.getWidth(); x++) {
+            for (int y = 0; y < image.getHeight(); y++) {
+                modifyPixel(image, x, y);
+            }
+        }
+    }
+
+    private void modifyPixel(GrayImage image, int x, int y) {
+        image.setPixel(image.getPixelGrayColor(x, y).invert(), x, y);
+    }
+}

src/main/java/Main.java

@@ -6,7 +6,6 @@ import javafx.stage.Stage;
 
 import java.io.IOException;
 
-
 public class Main extends Application
 {
 
@@ -18,8 +17,10 @@ public class Main extends Application
     public void start(Stage primaryStage) throws IOException {
         Parent root =FXMLLoader.load(getClass().getResource("fxml/Display.fxml"));
         primaryStage.setTitle("Image display");
+
         primaryStage.setScene(new Scene(root));
         primaryStage.show();
 
     }
+
 }

src/main/java/MatrixGrayImage.java

@@ -14,45 +14,45 @@ public class MatrixGrayImage implements GrayImage {
     private final int width;
     private final int height;
 
-
     @Override
     public void setPixel(GrayColor gray, int x, int y) {
-        // TODO : Compléter la méthode pour modifier le pixel.
+        pixels[x][y] = gray;
     }
 
     @Override
     public GrayColor getPixelGrayColor(int x, int y) {
-        // TODO : Changer les instructions pour retourner le bon pixel.
-        return new ByteGrayColor();
+        return pixels[x][y];
     }
 
     @Override
     public Color getPixelColor(int x, int y) {
-        // TODO : Changer les instructions pour retourner la couleur du pixel.
-        return Color.WHITE;
+        return getPixelGrayColor(x, y).getColor();
     }
 
     @Override
     public int getWidth() {
-        // TODO : Changer les instructions pour retourner la largeur de l'image.
-        return 600;
+        return width;
     }
 
     @Override
     public int getHeight() {
-        // TODO : Changer les instructions pour retourner la hauteur de l'image.
-        return 400;
+        return height;
     }
 
     public MatrixGrayImage(int width, int height){
-        /* TODO : Modifier les instructions pour initialiser correctement
-            les propriétés de l'instance.
-         */
-        this.width = 0;
-        this.height = 0;
-        this.pixels = null;
+        this.width = width;
+        this.height = height;
+        this.pixels = new GrayColor[width][height];
+        setAllPixelsColorTo(ByteGrayColor.WHITE);
     }
 
+    private void setAllPixelsColorTo(GrayColor gray) {
+        for(int x = 0; x < this.width; x++){
+            for (int y = 0; y < this.height; y++){
+                pixels[x][y] = gray;
+            }
+        }
+    }
 
     public static MatrixGrayImage createImageFromPGMFile(String fileName) {
         // NE PAS MODIFIER !
@@ -87,7 +87,7 @@ public class MatrixGrayImage implements GrayImage {
             printWriter.println("# CREATOR: TP3 Version 1.0");
             printWriter.printf("%d %d\n",this.width, this.height);
 
-            printWriter.println(pgmCodeOfGrayColor(pixels[0][0]));
+            printWriter.println(PGM_MAXIMUM_CODE);
 
             for(int y = 0; y < height; y++){
                 for(int x = 0; x < width; x++) {

src/main/java/Outline.java

+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Created by Arnaud Labourel on 04/10/2018.
+ */
+public class Outline implements Transform {
+    private final double threshold;
+
+    public Outline(double threshold) {
+        this.threshold = threshold;
+    }
+
+    private List<GrayColor> southEastNeighborPixels(GrayImage image, int x, int y){
+        List<GrayColor> neighborPixels = new ArrayList<>();
+        if (x != image.getWidth() - 1) {
+            neighborPixels.add(image.getPixelGrayColor(x + 1, y));
+        }
+        if (y != image.getHeight() - 1) {
+            neighborPixels.add(image.getPixelGrayColor(x, y + 1));
+        }
+        return neighborPixels;
+    }
+
+    @Override
+    public void applyTo(GrayImage image) {
+        for(int x = 0; x < image.getWidth(); x++) {
+            for(int y = 0; y < image.getHeight(); y++) {
+                modifyPixel(image, x, y);
+            }
+        }
+    }
+
+    private void modifyPixel(GrayImage image, int x, int y) {
+        List<GrayColor> neighborPixels = southEastNeighborPixels(image, x, y);
+        ByteGrayColor newColor = ByteGrayColor.WHITE;
+
+        for(GrayColor neighborPixel : neighborPixels){
+
+            if(Math.abs(neighborPixel.getLuminosity() - image.getPixelGrayColor(x,y).getLuminosity()) > threshold) {
+                newColor = ByteGrayColor.BLACK;
+            }
+        }
+
+        image.setPixel(newColor, x, y);
+    }
+
+}

src/main/java/Pixelate.java

+/**
+ * Created by Arnaud Labourel on 04/10/2018.
+ */
+public class Pixelate implements Transform{
+
+    private class PixelSquare {
+        private final int xTopLeft;
+        private final int yTopLeft;
+
+        public PixelSquare(int xTopLeft, int yTopLeft) {
+            this.xTopLeft = xTopLeft;
+            this.yTopLeft = yTopLeft;
+        }
+
+        void setAllPixelsColor(GrayColor grayColor, GrayImage image){
+            for(int x = xTopLeft; x < Math.min(xTopLeft + newPixelSize, image.getWidth()); x++) {
+                for (int y = yTopLeft; y < Math.min(yTopLeft + newPixelSize, image.getHeight()); y++) {
+                    image.setPixel(grayColor, x, y);
+                }
+            }
+        }
+
+        ByteGrayColor averageColorOfPixels(GrayImage image){
+            double sumOfLuminosities = 0;
+            int nbPixels = 0;
+            for(int x = xTopLeft; x < Math.min(xTopLeft + newPixelSize, image.getWidth()); x++) {
+                for (int y = yTopLeft; y < Math.min(yTopLeft + newPixelSize, image.getHeight()); y++) {
+                    sumOfLuminosities += image.getPixelGrayColor(x, y).getLuminosity();
+                    nbPixels++;
+                }
+            }
+            return new ByteGrayColor(sumOfLuminosities/nbPixels);
+        }
+    }
+
+    private final int newPixelSize;
+
+    public Pixelate(int newPixelSize) {
+        this.newPixelSize = newPixelSize;
+    }
+
+    @Override
+    public void applyTo(GrayImage image){
+        int rowCount = (int) Math.ceil((double)image.getWidth()/newPixelSize);
+        int columnCount = (int) Math.ceil((double)image.getHeight()/newPixelSize);
+
+        for(int i = 0; i < rowCount; i++)
+            for(int j = 0; j < columnCount; j++){
+                PixelSquare pixelSquare = new PixelSquare(i*newPixelSize, j*newPixelSize);
+                pixelSquare.setAllPixelsColor(pixelSquare.averageColorOfPixels(image), image);
+            }
+    }
+}

src/main/java/Transform.java

+/**
+ * Created by Arnaud Labourel on 04/10/2018.
+ */
+public interface Transform {
+    void applyTo(GrayImage image);
+}